module klang.ir.类型.IR类型_;
import 全局;
import klang.编译.核心.核心_: 整数_, 词典_, 创建数组;
import klang.编译.dataLayout.DataLayout: DataLayout;
import klang.编译.APSInt.APSInt_: APSInt_;
import klang.编译.APInt.APInt_: APInt_;
import klang.编译.APFloat.APFoat_: APFloat_, IEEEFloat_, DoubleAPFloat_;
import klang.编译.语法节点.节点_: 基础节点_ = 节点_;
import klang.编译.Align.Align_: Align_;
import klang.ir.语法节点.IR节点_: IR节点_;
import klang.编译.类型.类型_: 编译选项基类_, 符号_, 类型_, 签名_, 解析的模块名称_, 符号表_;
import klang.编译.类型.枚举值.枚举值_: TK;
alias 标点符号语法种类_ = ISK;
alias 关键字语法种类_ = ISK;
alias KeywordTypeSyntaxKind_ = ISK;
/* @internal */
alias TypeNodeSyntaxKind_ = ISK;
alias 杂项语法种类_ = ISK;
alias 字面量语法种类_ = ISK;
alias TokenSyntaxKind_ = ISK;
alias 调用约定令牌种类_ = ISK;
alias 线程位置令牌种类_ = ISK;
alias 线程位置模式令牌种类_ = ISK;
alias 函数特性令牌种类_ = ISK;
alias 函数对齐类特性令牌种类_ = ISK;
alias 形参特性令牌种类_ = ISK;
alias 形参对齐类特性令牌种类_ = ISK;
alias 形参不可引用特性令牌种类_ = ISK;
alias 形参类型相关特性令牌种类_ = ISK;
alias 返回特性令牌种类_ = ISK;
alias 返回对齐类特性令牌种类_ = ISK;
alias 返回不可引用特性令牌种类_ = ISK;
alias 链接模式令牌种类_ = ISK;
alias 可见性令牌种类_ = ISK;
alias DSO位置令牌种类_ = ISK;
alias Dll储存类令牌种类_ = ISK;
alias 未命名地址令牌种类_ = ISK;
alias 函数或形参共有令牌种类_ = ISK;
enum ISK : int {
    未知__ = 0,
    文件结尾 = 1,
    单行注释 = 2,
    多行注释 = 3,
    新行 = 4,
    空白 = 5,
    指令注释 = 6,
    冲突标记 = 7,
    数字字面量 = 8,
    文本字面量 = 9,
    c文本字面量 = 10,
    左大括号 = 11,
    右大括号 = 12,
    左括号 = 13,
    右括号 = 14,
    左方括号 = 15,
    右方括号 = 16,
    双引号 = 17,
    单引号 = 18,
    点号 = 19,
    分号 = 20,
    逗号 = 21,
    左尖括号 = 22,
    右尖括号 = 23,
    加号 = 24,
    减号 = 25,
    星号 = 26,
    反斜杠 = 27,
    除号 = 28,
    百分号 = 29,
    且号 = 30,
    或号 = 31,
    异或号 = 32,
    叹号 = 33,
    波折号 = 34,
    美元 = 35,
    问号 = 36,
    冒号 = 37,
    艾特 = 38,
    井号 = 39,
    反引号 = 40,
    等号 = 41,
    下划线 = 42,
    连续运算符 = 43,
    保留不使用标识符 = 44,
    保留不使用目标 = 45,
    保留不使用类型符号签名系统 = 46,
    保留不使用源文件 = 47,
    三点号 = 48,
    x = 49,
    /** 标识符 */
    标识符 = 50,
    /** 定义 */
    define = 51,
    /** 真 */
    true_ = 52,
    /** 假 */
    false_ = 53,
    /** 声明 */
    declare = 54,
    /** 全局 */
    global = 55,
    /** 常数 */
    constant = 56,
    /** dso_本地 */
    dso_local = 57,
    /** dso_可抢占 */
    dso_preemptable = 58,
    /** 私有 */
    private_ = 59,
    /** 内部 */
    internal = 60,
    /** 链接一次 */
    linkonce = 61,
    /** 链接一次_旧的 */
    linkonce_odr = 62,
    /** 弱链 */
    weak = 63,
    /** 弱链_旧的 */
    weak_odr = 64,
    /** 附加的 */
    appending = 65,
    /** dll导入 */
    dllimport = 66,
    /** dll导出 */
    dllexport = 67,
    /** 常见的 */
    common = 68,
    /** 外部_可用 */
    available_externally = 69,
    /** 默认 */
    default_ = 70,
    /** 隐藏 */
    hidden = 71,
    /** 保护 */
    protected_ = 72,
    /** 未命名地址 */
    unnamed_addr = 73,
    /** 本地未命名地址 */
    local_unnamed_addr = 74,
    /** 外部初始化 */
    externally_initialized = 75,
    /** 外部_弱 */
    extern_weak = 76,
    /** 外部的 */
    external = 77,
    /** 本地线程 */
    thread_local = 78,
    /** 动态加载 */
    localdynamic = 79,
    /** 初始执行 */
    initialexec = 80,
    /** 本地执行 */
    localexec = 81,
    /** 零值初始 */
    zeroinitializer = 82,
    /** 未定 */
    undef = 83,
    /** 毒值 */
    poison = 84,
    /** 空 */
    null_ = 85,
    /** 无 */
    none = 86,
    /** 到 */
    to = 87,
    /** 调用者 */
    caller = 88,
    /** 在内部 */
    within = 89,
    /** 从 */
    from = 90,
    /** 尾调 */
    tail = 91,
    /** 必须尾调 */
    musttail = 92,
    /** 不尾调 */
    notail = 93,
    /** 目标 */
    target = 94,
    /** 平台 */
    triple = 95,
    /** 源码文件名 */
    source_filename = 96,
    /** 展开 */
    unwind = 97,
    /** 数据布局 */
    datalayout = 98,
    /** 易变的 */
    volatile = 99,
    /** 原子 */
    atomic = 100,
    /** 无序的 */
    unordered = 101,
    /** 不变的 */
    monotonic = 102,
    /** 获得 */
    acquire = 103,
    /** 释放 */
    release = 104,
    /** 获得_释放 */
    acq_rel = 105,
    /** 顺序一致 */
    seq_cst = 106,
    /** 同步范围 */
    syncscope = 107,
    /** 允许非数字 */
    nnan = 108,
    /** 允许无穷大 */
    ninf = 109,
    /** 允许无符号零 */
    nsz = 110,
    /** 允许倒数 */
    arcp = 111,
    /** 允许小数压缩 */
    contract = 112,
    /** 允许重装 */
    reassoc = 113,
    /** 允许近似 */
    afn = 114,
    /** 快速 */
    fast = 115,
    /** 不包装无符号 */
    nuw = 116,
    /** 不包装有符号 */
    nsw = 117,
    /** 精确的 */
    exact = 118,
    /** 在界内 */
    inbounds = 119,
    /** 在范围 */
    inrange = 120,
    /** 对齐 */
    align_ = 121,
    /** 地址空间 */
    addrspace = 122,
    /** 段 */
    section = 123,
    /** 隔板 */
    partition = 124,
    /** 别名 */
    alias_ = 125,
    /** 函数别名 */
    ifunc = 126,
    /** 模块 */
    module_ = 127,
    /** 汇编 */
    asm_ = 128,
    /** 副作用 */
    sideeffect = 129,
    /** 对齐堆栈 */
    alignstack = 130,
    /** 因特尔方言 */
    inteldialect = 131,
    /** 垃圾回收 */
    gc = 132,
    /** 前缀 */
    prefix = 133,
    /** 序言 */
    prologue = 134,
    c = 135,
    /** 约定 */
    cc = 136,
    /** c约定 */
    ccc = 137,
    /** 快速约定 */
    fastcc = 138,
    /** 冷约定 */
    coldcc = 139,
    /** 因特尔约定 */
    intel_ocl_bicc = 140,
    /** 守卫检查约定 */
    cfguard_checkcc = 141,
    /** x86_标准约定 */
    x86_stdcallcc = 142,
    /** x86_快速约定 */
    x86_fastcallcc = 143,
    /** x86_本体约定 */
    x86_thiscallcc = 144,
    /** x86_矢量约定 */
    x86_vectorcallcc = 145,
    /** x86_寄存器约定 */
    x86_regcallcc = 146,
    /** arm_apcs约定 */
    arm_apcscc = 147,
    /** arm_aapcs约定 */
    arm_aapcscc = 148,
    /** arm_aapcs_vfp约定 */
    arm_aapcs_vfpcc = 149,
    /** aarch64_矢量_pcs约定 */
    aarch64_vector_pcs = 150,
    /** aarch64_sve_矢量_pcs约定 */
    aarch64_sve_vector_pcs = 151,
    /** msp430_intr约定 */
    msp430_intrcc = 152,
    /** avr_intr约定 */
    avr_intrcc = 153,
    /** avr_信号约定 */
    avr_signalcc = 154,
    /** ptx_内核约定 */
    ptx_kernel = 155,
    /** ptx_设备约定 */
    ptx_device = 156,
    /** spir_内核约定 */
    spir_kernel = 157,
    /** spir_函数约定 */
    spir_func = 158,
    /** x86_64_系统约定 */
    x86_64_sysvcc = 159,
    /** win64约定 */
    win64cc = 160,
    /** 网络js约定 */
    webkit_jscc = 161,
    /** 任意约定 */
    anyregcc = 162,
    /** 雨燕约定 */
    swiftcc = 163,
    /** 雨燕尾约定 */
    swifttailcc = 164,
    /** 保存最多约定 */
    preserve_mostcc = 165,
    /** 保留所有约定 */
    preserve_allcc = 166,
    /** ghc约定 */
    ghccc = 167,
    /** x86_intr约定 */
    x86_intrcc = 168,
    /** hhvm约定 */
    hhvmcc = 169,
    /** hhvm_c约定 */
    hhvm_ccc = 170,
    /** c加加_快速_tls约定 */
    cxx_fast_tlscc = 171,
    /** amd显卡_vs */
    amdgpu_vs = 172,
    /** amd显卡_ls */
    amdgpu_ls = 173,
    /** amd显卡_hs */
    amdgpu_hs = 174,
    /** amd显卡_es */
    amdgpu_es = 175,
    /** amd显卡_gs */
    amdgpu_gs = 176,
    /** amd显卡_ps */
    amdgpu_ps = 177,
    /** amd显卡_cs */
    amdgpu_cs = 178,
    /** amd显卡_内核 */
    amdgpu_kernel = 179,
    /** amd显卡_gfx */
    amdgpu_gfx = 180,
    /** 尾约定 */
    tailcc = 181,
    /** 特性 */
    attributes = 182,
    /** 分配大小 */
    allocsize = 183,
    /** 总是内联 */
    alwaysinline = 184,
    /** 仅指针参数指向的内存 */
    argmemonly = 185,
    /** 清理地址 */
    sanitize_address = 186,
    /** 清理硬件地址 */
    sanitize_hwaddress = 187,
    /** 清理内存标签 */
    sanitize_memtag = 188,
    /** 内置 */
    builtin = 189,
    /** 按值 */
    byval = 190,
    /** 元素类型 */
    elementtype = 191,
    /** 在内部分配 */
    inalloca = 192,
    /** 冷的 */
    cold = 193,
    /** 聚合 */
    convergent = 194,
    /* 禁止内存边界检测 */
    disable_sanitizer_instrumentation = 195,
    /** 不可引用的 */
    dereferenceable = 196,
    /** 不可引用的或空 */
    dereferenceable_or_null = 197,
    /** 仅不可访问 */
    inaccessiblememonly = 198,
    /** 不可访问或仅参数内存 */
    inaccessiblemem_or_argmemonly = 199,
    /** 内联提示 */
    inlinehint = 200,
    /** 在寄存器 */
    inreg = 201,
    /** 跳转表 */
    jumptable = 202,
    /** 最小大小 */
    minsize = 203,
    /** 暴露的 */
    naked = 204,
    /** 嵌套 */
    nest = 205,
    /** 无别名 */
    noalias = 206,
    /** 无未定 */
    noundef = 207,
    /** 无内置 */
    nobuiltin = 208,
    /** 无回调 */
    nocallback = 209,
    /** 无捕获 */
    nocapture = 210,
    /** 无重复项 */
    noduplicate = 211,
    /** 无释放 */
    nofree = 212,
    /** 无隐式小数 */
    noimplicitfloat = 213,
    /** 非内联 */
    noinline = 214,
    /** 无递归 */
    norecurse = 215,
    /** 非惰性绑定 */
    nonlazybind = 216,
    /** 不合并 */
    nomerge = 217,
    /** 非空 */
    nonnull = 218,
    /** 无描述 */
    noprofile = 219,
    /** 无红色区 */
    noredzone = 220,
    /** 无返回 */
    noreturn = 221,
    /** 不同步 */
    nosync = 222,
    /** 不cf检查 */
    nocf_check = 223,
    /** 不展开 */
    nounwind = 224,
    /** 无消毒覆盖范围 */
    nosanitize_coverage = 225,
    /** 空指针有效 */
    null_pointer_is_valid = 226,
    /** 模糊优化 */
    optforfuzzing = 227,
    /** 无优化 */
    optnone = 228,
    /** 优化大小 */
    optsize = 229,
    /** 预分配 */
    preallocated = 230,
    /** 不读 */
    readnone = 231,
    /** 只读 */
    readonly = 232,
    /** 返回的 */
    returned = 233,
    /** 返回两次 */
    returns_twice = 234,
    /** 符号文本 */
    signext = 235,
    /** 可推测的 */
    speculatable = 236,
    /** 堆栈保护 */
    ssp = 237,
    /** 堆栈溢出保护 */
    sspreq = 238,
    /** 堆栈溢出保护加强 */
    sspstrong = 239,
    /** 安全堆栈 */
    safestack = 240,
    /** 影子调用堆栈 */
    shadowcallstack = 241,
    /** 结构引用 */
    sret = 242,
    /** 消毒线程 */
    sanitize_thread = 243,
    /** 消毒内存 */
    sanitize_memory = 244,
    /** 推测加载强化 */
    speculative_load_hardening = 245,
    /** 严格函数指针 */
    strictfp = 246,
    /** 雨燕错误 */
    swifterror = 247,
    /** 雨燕自我 */
    swiftself = 248,
    /** 雨燕异步 */
    swiftasync = 249,
    /** 展开表实体 */
    uwtable = 250,
    /** 倍数_范围 */
    vscale_range = 251,
    /** 明确返回 */
    willreturn = 252,
    /** 只写 */
    writeonly = 253,
    /** 零文本 */
    zeroext = 254,
    /** 立即参数 */
    immarg = 255,
    /** 按引用 */
    byref = 256,
    /** 必须进步 */
    mustprogress = 257,
    /** 类型 */
    type = 258,
    /** 封闭 */
    opaque = 259,
    /** 函数封装 */
    comdat = 260,
    /** 任意 */
    any = 261,
    /** 精确匹配 */
    exactmatch = 262,
    /** 最大匹配 */
    largest = 263,
    /** 无重复项组 */
    noduplicates = 264,
    /** 相同大小 */
    samesize = 265,
    /** 赋值 */
    xchg = 266,
    /**==*/
    eq = 267,
    /**!=*/
    ne = 268,
    /**s<*/
    slt = 269,
    /**s\>*/
    sgt = 270,
    /**s<=*/
    sle = 271,
    /**s>=*/
    sge = 272,
    /**u<*/
    ult = 273,
    /**u>*/
    ugt = 274,
    /**u<=*/
    ule = 275,
    /**u>=*/
    uge = 276,
    /**o==*/
    oeq = 277,
    /**o!=*/
    one = 278,
    /**o<*/
    olt = 279,
    /**o>*/
    ogt = 280,
    /**o<=*/
    ole = 281,
    /**o>=*/
    oge = 282,
    /**o=*/
    ord = 283,
    /**uo=*/
    uno = 284,
    /**uo==*/
    ueq = 285,
    /**uo!=*/
    une = 286,
    /** 且取反 */
    nand = 287,
    /** 最大 */
    max = 288,
    /** 最小 */
    min = 289,
    /** 无符号最大 */
    umax = 290,
    /** 无符号最小 */
    umin = 291,
    /** 取反 */
    fneg = 292,
    /** 求和 */
    add = 293,
    /** 小数求和 */
    fadd = 294,
    /** 求差 */
    sub = 295,
    /** 小数求差 */
    fsub = 296,
    /** 求积 */
    mul = 297,
    /** 小数求积 */
    fmul = 298,
    /** 无符号求商 */
    udiv = 299,
    /** 有符号求商 */
    sdiv = 300,
    /** 小数求商 */
    fdiv = 301,
    /** 无符号求余 */
    urem = 302,
    /** 有符号求余 */
    srem = 303,
    /** 小数求余 */
    frem = 304,
    /** 左移 */
    shl = 305,
    /** 逻辑右移 */
    lshr = 306,
    /** 有符号右移 */
    ashr = 307,
    /** 且 */
    and = 308,
    /** 或 */
    or = 309,
    /** 异或 */
    xor = 310,
    /** 整数比较 */
    icmp = 311,
    /** 小数比较 */
    fcmp = 312,
    /** PHI节点 */
    phi = 313,
    /** 调用 */
    call = 314,
    /** 截断转换 */
    trunc = 315,
    /** 零扩展转换 */
    zext = 316,
    /** 符号扩展转换 */
    sext = 317,
    /** 小数截断转换 */
    fptrunc = 318,
    /** 小数扩展转换 */
    fpext = 319,
    /** 无符号整数到小数转换 */
    uitofp = 320,
    /** 有符号整数到小数转换 */
    sitofp = 321,
    /** 小数到无符号整数转换 */
    fptoui = 322,
    /** 小数到有符号整数转换 */
    fptosi = 323,
    /** 整数到指针转换 */
    inttoptr = 324,
    /** 指针到整数转换 */
    ptrtoint = 325,
    /** 位转换 */
    bitcast = 326,
    /** 地址空间转换 */
    addrspacecast = 327,
    /** 选择 */
    select = 328,
    /** 可变参数_实参 */
    va_arg = 329,
    /** 着陆场 */
    landingpad = 330,
    /** 个性 */
    personality = 331,
    /** 清理 */
    cleanup = 332,
    /** 捕获 */
    catch_ = 333,
    /** 过滤 */
    filter = 334,
    /** 返回 */
    ret = 335,
    /** 跳转 */
    br = 336,
    /** 假如 */
    switch_ = 337,
    /** 直接跳转 */
    indirectbr = 338,
    /** 唤出 */
    invoke = 339,
    /** 重启 */
    resume = 340,
    /** 不及 */
    unreachable = 341,
    /** 清理返回 */
    cleanupret = 342,
    /** 捕获分支 */
    catchswitch = 343,
    /** 捕获返回 */
    catchret = 344,
    /** 捕获场 */
    catchpad = 345,
    /** 清理着陆场 */
    cleanuppad = 346,
    /** 调用跳转 */
    callbr = 347,
    /** 分配 */
    alloca = 348,
    /** 加载 */
    load = 349,
    /** 储存 */
    store = 350,
    /** 栅格 */
    fence = 351,
    /** 原子修改内存按条件 */
    cmpxchg = 352,
    /** 原子修改内存 */
    atomicrmw = 353,
    /** 获取元素指针 */
    getelementptr = 354,
    /** 提取元素 */
    extractelement = 355,
    /** 插入元素 */
    insertelement = 356,
    /** 洗牌向量 */
    shufflevector = 357,
    /** 提取值 */
    extractvalue = 358,
    /** 插入值 */
    insertvalue = 359,
    /** 块地址 */
    blockaddress = 360,
    /** dso_局部_等效 */
    dso_local_equivalent = 361,
    /** 冻结 */
    freeze = 362,
    /** 新鲜的 */
    distinct = 363,
    /** 用户历史记录 */
    uselistorder = 364,
    /** 用户历史记录bb */
    uselistorder_bb = 365,
    // 类型关键字
    void_ = 366,
    /** f16 */
    half = 367,
    /** fb16 */
    bfloat = 368,
    /** f32 */
    float_ = 369,
    /** f64 */
    double_ = 370,
    /** f80 */
    x86_fp80 = 371,
    /** f128 */
    fp128 = 372,
    /** pf128 */
    ppc_fp128 = 373,
    /** 标签 */
    label = 374,
    /** 元数据 */
    metadata = 375,
    /** mmx */
    x86_mmx = 376,
    /** amx */
    x86_amx = 377,
    /** 指针 */
    ptr = 378,
    /** 类型 */
    Type = 379,
    /** 令牌 */
    token = 380,
    /** 路径 */
    path = 381,
    /** 哈希 */
    hash = 382,
    /** 全局值 */
    gv = 383,
    /** 唯一标识符 */
    guid = 384,
    /** 名称 */
    name = 385,
    /** 摘要组 */
    summaries = 386,
    /** 标志 */
    flags = 387,
    /** 块数 */
    blockcount = 388,
    /** 链接模式说明 */
    linkage = 389,
    /** 可见性 */
    visibility = 390,
    /** 没有资格导入 */
    notEligibleToImport = 391,
    /** 存活 */
    live = 392,
    /** dso本地 */
    dsoLocal = 393,
    /** 可以自动隐藏 */
    canAutoHide = 394,
    /** 函数 */
    function_ = 395,
    /** 学院组 */
    insts = 396,
    /** 函数标志 */
    funcFlags = 397,
    /** 不可读的 */
    readNone = 398,
    /** 只读的 */
    readOnly = 399,
    /** 不可递归 */
    noRecurse = 400,
    /** 返回不包含别名 */
    returnDoesNotAlias = 401,
    /** 绝不内联 */
    noInline = 402,
    /** 始终内联 */
    alwaysInline = 403,
    /** 不展开标志  */
    noUnwind = 404,
    /** 可以抛出 */
    mayThrow = 405,
    /** 有未知调用 */
    hasUnknownCall = 406,
    /** 调用组 */
    calls = 407,
    /** 被调用者 */
    callee = 408,
    /** 形参组 */
    params = 409,
    /** 形参 */
    param = 410,
    /** 热度 */
    hotness = 411,
    /** 未知 */
    unknown = 412,
    /** 热的 */
    hot = 413,
    /** 关键的 */
    critical = 414,
    /** 相对分支频率 */
    relbf = 415,
    /** 变量 */
    variable = 416,
    /** 虚表函数组 */
    vTableFuncs = 417,
    /** 虚函数 */
    virtFunc = 418,
    /** 别名组 */
    aliasee = 419,
    /** 引用组 */
    refs = 420,
    /** 类型id信息 */
    typeIdInfo = 421,
    /** 类型测试组 */
    typeTests = 422,
    /** 类型测试假定调用 */
    typeTestAssumeVCalls = 423,
    /** 类型检查加载调用 */
    typeCheckedLoadVCalls = 424,
    /** 类型测试假定常量调用 */
    typeTestAssumeConstVCalls = 425,
    /** 类型检查加载常量调用 */
    typeCheckedLoadConstVCalls = 426,
    /** 虚函数Id */
    vFuncId = 427,
    /** 偏移集合 */
    offset = 428,
    /** 实参组 */
    args = 429,
    /** 类型Id */
    typeid_ = 430,
    /** 类型id兼容表 */
    typeidCompatibleVTable = 431,
    /** 摘要 */
    summary = 432,
    /** 类型测试资源 */
    typeTestRes = 433,
    /** 种类 */
    kind = 434,
    /** 不安全 */
    unsat = 435,
    /** 比特数组 */
    byteArray = 436,
    /** 内联 */
    inline = 437,
    /** 单一的 */
    single = 438,
    /** 全部的 */
    allOnes = 439,
    /** M1位宽度大小 */
    sizeM1BitWidth = 440,
    /** 对齐日志2 */
    alignLog2 = 441,
    /** M1大小 */
    sizeM1 = 442,
    /** 位掩码 */
    bitMask = 443,
    /** 内联位组 */
    inlineBits = 444,
    /** 调用可见性 */
    vcall_visibility = 445,
    /** 全程序驱动解决方案 */
    wpdResolutions = 446,
    /** 全程序驱动方案 */
    wpdRes = 447,
    /** 在目录内 */
    indir = 448,
    /** 单一实例 */
    singleImpl = 449,
    /** 使用分支 */
    branchFunnel = 450,
    /** 单一实例名称 */
    singleImplName = 451,
    /** 资源按参数 */
    resByArg = 452,
    /** 按参数 */
    byArg = 453,
    /** 均匀收益值优化 */
    uniformRetVal = 454,
    /** 唯一回报值优化 */
    uniqueRetVal = 455,
    /** 虚常数传播 */
    virtualConstProp = 456,
    /** 信息 */
    info = 457,
    /** 字节 */
    byte_ = 458,
    /** 比特 */
    bit = 459,
    /** 变量标志 */
    varFlags = 460,
    /** 无值 */
    /** 倍数 */
    vscale = 461,
    Error = 462,
    APFloat = 463,
    GlobalVar = 464,
    GlobalID = 465,
    ComdatVar = 466,
    LocalVar = 467,
    LocalVarID = 468,
    LabelStr = 469,
    LabelID = 470,
    StringConstant = 471,
    MetadataVar = 472,
    SummaryID = 473,
    AttrGrpID = 474,
    APSInt = 475,
    DW_TAG_ = 476,
    DW_ATE_ = 477,
    DW_VIRTUALITY_ = 478,
    DW_LANG_ = 479,
    DW_CC_ = 480,
    DW_OP_ = 481,
    DW_MACINFO_ = 482,
    DwarfTag = 483,
    DwarfAttEncoding = 484,
    DwarfVirtuality = 485,
    DwarfLang = 486,
    DwarfCC = 487,
    DwarfOp = 488,
    DwarfMacinfo = 489,
    DIFlag = 490,
    DISPFlag = 491,
    ChecksumKind = 492,
    EmissionKind = 493,
    NameTableKind = 494,
    MDNodeVector = 495,
    StandaloneMetadata = 496,
    DIExpression = 497,
    DIArgList = 498,
    数据计算字段 = 499,
    类型引用 = 500,
    整数类型 = 501,
    结构类型 = 502,
    数组类型 = 503,
    向量类型 = 504,
    函数类型 = 505,
    指针类型 = 506,
    元数据字段 = 507,
    专用元数据字段 = 508,
    操作数标签 = 509,
    操作数标签组 = 510,
    全局表达式 = 511,
    结构常量表达式 = 512,
    向量常量表达式 = 513,
    数组常量表达式 = 514,
    c文本常量 = 515,
    内联汇编常量表达式 = 516,
    块地址表常量表达式 = 517,
    DSO局部等效常量表达式 = 518,
    常量转换类节点 = 519,
    提取值常量表达式 = 520,
    插入值常量表达式 = 521,
    比较类常量表达式 = 522,
    取反常量表达式 = 523,
    二元常量表达式 = 524,
    逻辑类常量表达式 = 525,
    获取元素指针常量表达式 = 526,
    向量洗牌常量表达式 = 527,
    插入元素常量表达式 = 528,
    提取元素常量表达式 = 529,
    选择常量表达式 = 530,
    值表达式 = 531,
    跳转表元素 = 532,
    实参表达式 = 533,
    分配大小设置内容 = 534,
    倍数范围设置内容 = 535,
    平台设置 = 536,
    封装设置 = 537,
    CC调用约定设置 = 538,
    数据布局设置 = 539,
    按值设置 = 540,
    结构引用设置 = 541,
    地址空间设置 = 542,
    对齐设置 = 543,
    不可引用的设置 = 544,
    不可引用的或空设置 = 545,
    对齐堆栈设置 = 546,
    分配大小设置 = 547,
    倍数范围设置 = 548,
    预分配设置 = 549,
    在内部分配设置 = 550,
    按引用设置 = 551,
    同步范围设置 = 552,
    自定义特性设置 = 553,
    本地线程设置 = 554,
    // 摘要表达式
    被调用者摘要 = 555,
    摘要多值设置 = 556,
    摘要值设置 = 557,
    全局值摘要 = 558,
    全局值引用摘要 = 559,
    虚函数id摘要 = 560,
    常量虚调用摘要 = 561,
    形参偏移摘要 = 562,
    形参访问调用摘要 = 563,
    形参访问摘要 = 564,
    函数摘要 = 565,
    虚函数摘要 = 566,
    变量摘要 = 567,
    模块摘要 = 568,
    类型id内容摘要 = 569,
    类型id兼容表摘要 = 570,
    别名摘要 = 571,
    偏移及引用 = 572,
    // 函数声明
    形参声明 = 573,
    // 设置型语句
    源码文件名语句 = 574,
    目标语句 = 575,
    模块级汇编 = 576,
    函数体 = 577,
    函数声明 = 578,
    函数定义 = 579,
    元数据声明 = 580,
    独立元数据 = 581,
    特性声明 = 582,
    全局变量声明 = 583,
    局部变量声明 = 584,
    别名声明 = 585,
    封装声明 = 586,
    全局摘要声明 = 587,
    类型声明 = 588,
    用户历史数据 = 589,
    用户历史数据_基本块 = 590,
    块声明 = 591,
    // 指令语句
    不及指令 = 592,
    返回指令 = 593,
    跳转指令 = 594,
    假如指令 = 595,
    直接跳转指令 = 596,
    唤出指令 = 597,
    重启指令 = 598,
    清理返回指令 = 599,
    捕获返回指令 = 600,
    捕获分支指令 = 601,
    调用跳转指令 = 602,
    取反指令 = 603,
    整数和差积及左移指令 = 604,
    小数和差积及左移指令 = 605,
    有无符号求商及右移指令 = 606,
    有无符号求余数运算指令 = 607,
    位运算指令 = 608,
    比较运算指令 = 609,
    转换类指令 = 610,
    选择指令 = 611,
    可变参数指令 = 612,
    提取元素指令 = 613,
    插入元素指令 = 614,
    洗牌向量指令 = 615,
    PHI节点指令 = 616,
    PHI节点元素 = 617,
    着陆场指令 = 618,
    捕获场指令 = 619,
    清理场指令 = 620,
    捕获或过滤器 = 621,
    冻结指令 = 622,
    调用指令 = 623,
    分配指令 = 624,
    加载指令 = 625,
    储存指令 = 626,
    原子修改内存按条件指令 = 627,
    原子修改内存指令 = 628,
    栅格指令 = 629,
    获取元素指针指令 = 630,
    提取值指令 = 631,
    插入值指令 = 632,
    空语句 = 633,
    源文件 = 634,
    // 632
    数量_ = 635
}
enum 节点标志_ : ulong {
    无 = 0uL,
    节点有错误 = 1uL,
    节点或子节点有错误 = 2uL,
    已聚合了子节点错误 = 4uL,
    有JsDoc = 8uL,
    节点组中最后一个 = 16uL,
    不输出文件 = 32uL,
    Synthesized = 64uL,
    C = 35184372088832uL,
    F = 70368744177664uL,
    有转义 = 140737488355328uL,
    有扩展转义 = 281474976710656uL,
    IEEEdouble = 562949953421312uL,
    x87DoubleExtended = 1125899906842624uL,
    IEEEquad = 2251799813685248uL,
    PPCDoubleDouble = 4503599627370496uL,
    IEEEhalf = 9007199254740992uL,
    BFloat = 18014398509481984uL,
    正整数64_ = 36028797018963968uL,
    数字或负数_ = 72057594037927936uL,
    US十六进制_ = 144115188075855872uL,
    是有符号的_ = 288230376151711744uL,
    是文本内容_ = 576460752303423488uL,
    MD_ = 1152921504606846976uL,
    未解码转义 = 2305843009213693952uL,
    合成的_ = 4611686018427387904uL,
    完成检查_ = 9223372036854775808uL
}
enum AttrKind_ : int {
    None = 0,
    AlwaysInline = 1,
    ArgMemOnly = 2,
    Builtin = 3,
    Cold = 4,
    Convergent = 5,
    DisableSanitizerInstrumentation = 6,
    Hot = 7,
    ImmArg = 8,
    InReg = 9,
    InaccessibleMemOnly = 10,
    InaccessibleMemOrArgMemOnly = 11,
    InlineHint = 12,
    JumpTable = 13,
    MinSize = 14,
    MustProgress = 15,
    Naked = 16,
    Nest = 17,
    NoAlias = 18,
    NoBuiltin = 19,
    NoCallback = 20,
    NoCapture = 21,
    NoCfCheck = 22,
    NoDuplicate = 23,
    NoFree = 24,
    NoImplicitFloat = 25,
    NoInline = 26,
    NoMerge = 27,
    NoProfile = 28,
    NoRecurse = 29,
    NoRedZone = 30,
    NoReturn = 31,
    NoSanitizeCoverage = 32,
    NoSync = 33,
    NoUndef = 34,
    NoUnwind = 35,
    NonLazyBind = 36,
    NonNull = 37,
    NullPointerIsValid = 38,
    OptForFuzzing = 39,
    OptimizeForSize = 40,
    OptimizeNone = 41,
    ReadNone = 42,
    ReadOnly = 43,
    Returned = 44,
    ReturnsTwice = 45,
    SExt = 46,
    SafeStack = 47,
    SanitizeAddress = 48,
    SanitizeHWAddress = 49,
    SanitizeMemTag = 50,
    SanitizeMemory = 51,
    SanitizeThread = 52,
    ShadowCallStack = 53,
    Speculatable = 54,
    SpeculativeLoadHardening = 55,
    StackProtect = 56,
    StackProtectReq = 57,
    StackProtectStrong = 58,
    StrictFP = 59,
    SwiftAsync = 60,
    SwiftError = 61,
    SwiftSelf = 62,
    UWTable = 63,
    WillReturn = 64,
    WriteOnly = 65,
    ZExt = 66,
    ByRef = 67,
    ByVal = 68,
    ElementType = 69,
    InAlloca = 70,
    Preallocated = 71,
    StructRet = 72,
    Alignment = 73,
    AllocSize = 74,
    Dereferenceable = 75,
    DereferenceableOrNull = 76,
    StackAlignment = 77,
    VScaleRange = 78,
    FirstEnumAttr = 1,
    LastEnumAttr = 66,
    FirstTypeAttr = 67,
    LastTypeAttr = 72,
    FirstIntAttr = 73,
    LastIntAttr = 78
}
enum CallingConv_ : int {
    /// C - The default llvm calling convention, compatible with C.  This
    /// convention is the only calling convention that supports varargs calls.
    /// As with typical C calling conventions, the callee/caller have to
    /// tolerate certain amounts of prototype mismatch.
    C = 0,
    // Generic LLVM calling conventions.  None of these calling conventions
    // support varargs calls, and all assume that the caller and callee
    // prototype exactly match.
    /// Fast - This calling convention attempts to make calls as fast as
    /// possible (e.g. by passing things in registers).
    Fast = 8,
    // Cold - This calling convention attempts to make code in the caller as
    // efficient as possible under the assumption that the call is not commonly
    // executed.  As such, these calls often preserve all registers so that the
    // call does not break any live ranges in the caller side.
    Cold = 9,
    // GHC - Calling convention used by the Glasgow Haskell Compiler (GHC).
    GHC = 10,
    // HiPE - Calling convention used by the High-Performance Erlang Compiler
    // (HiPE).
    HiPE = 11,
    // WebKit JS - Calling convention for stack based JavaScript calls
    WebKit_JS = 12,
    // AnyReg - Calling convention for dynamic register based calls (e.g.
    // stackmap and patchpoint intrinsics).
    AnyReg = 13,
    // PreserveMost - Calling convention for runtime calls that preserves most
    // registers.
    PreserveMost = 14,
    // PreserveAll - Calling convention for runtime calls that preserves
    // (almost) all registers.
    PreserveAll = 15,
    // Swift - Calling convention for Swift.
    Swift = 16,
    // CXX_FAST_TLS - Calling convention for access functions.
    CXX_FAST_TLS = 17,
    /// Tail - This calling convention attemps to make calls as fast as
    /// possible while guaranteeing that tail call optimization can always
    /// be performed.
    Tail = 18,
    /// Special calling convention on Windows for calling the Control
    /// Guard Check ICall funtion. The function takes exactly one argument
    /// (address of the target function) passed in the first argument register,
    /// and has no return value. All register values are preserved.
    CFGuard_Check = 19,
    /// SwiftTail - This follows the Swift calling convention in how arguments
    /// are passed but guarantees tail calls will be made by making the callee
    /// clean up their stack.
    SwiftTail = 20,
    // Target - This is the start of the target-specific calling conventions,
    // e.g. fastcall and thiscall on X86.
    FirstTargetCC = 64,
    /// X86_StdCall - stdcall is the calling conventions mostly used by the
    /// Win32 API. It is basically the same as the C convention with the
    /// difference in that the callee is responsible for popping the arguments
    /// from the stack.
    X86_StdCall = 64,
    /// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments
    /// in ECX:EDX registers, others - via stack. Callee is responsible for
    /// stack cleaning.
    X86_FastCall = 65,
    /// ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete,
    /// but still used on some targets).
    ARM_APCS = 66,
    /// ARM_AAPCS - ARM Architecture Procedure Calling Standard calling
    /// convention (aka EABI). Soft float variant.
    ARM_AAPCS = 67,
    /// ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
    ARM_AAPCS_VFP = 68,
    /// MSP430_INTR - Calling convention used for MSP430 interrupt routines.
    MSP430_INTR = 69,
    /// X86_ThisCall - Similar to X86_StdCall. Passes first argument in ECX,
    /// others via stack. Callee is responsible for stack cleaning. MSVC uses
    /// this by default for methods in its ABI.
    X86_ThisCall = 70,
    /// PTX_Kernel - Call to a PTX kernel.
    /// Passes all arguments in parameter space.
    PTX_Kernel = 71,
    /// PTX_Device - Call to a PTX device function.
    /// Passes all arguments in register or parameter space.
    PTX_Device = 72,
    /// SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
    /// No lowering or expansion of arguments.
    /// Structures are passed as a pointer to a struct with the byval attribute.
    /// Functions can only call SPIR_FUNC and SPIR_KERNEL functions.
    /// Functions can only have zero or one return values.
    /// Variable arguments are not allowed, except for printf.
    /// How arguments/return values are lowered are not specified.
    /// Functions are only visible to the devices.
    SPIR_FUNC = 75,
    /// SPIR_KERNEL - Calling convention for SPIR kernel functions.
    /// Inherits the restrictions of SPIR_FUNC, except
    /// Cannot have non-void return values.
    /// Cannot have variable arguments.
    /// Can also be called by the host.
    /// Is externally visible.
    SPIR_KERNEL = 76,
    /// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins
    Intel_OCL_BI = 77,
    /// The C convention as specified in the x86-64 supplement to the
    /// System V ABI, used on most non-Windows systems.
    X86_64_SysV = 78,
    /// The C convention as implemented on Windows/x86-64 and
    /// AArch64. This convention differs from the more common
    /// \c X86_64_SysV convention in a number of ways, most notably in
    /// that XMM registers used to pass arguments are shadowed by GPRs,
    /// and vice versa.
    /// On AArch64, this is identical to the normal C (AAPCS) calling
    /// convention for normal functions, but floats are passed in integer
    /// registers to variadic functions.
    Win64 = 79,
    /// MSVC calling convention that passes vectors and vector aggregates
    /// in SSE registers.
    X86_VectorCall = 80,
    /// Calling convention used by HipHop Virtual Machine (HHVM) to
    /// perform calls to and from translation cache, and for calling PHP
    /// functions.
    /// HHVM calling convention supports tail/sibling call elimination.
    HHVM = 81,
    /// HHVM calling convention for invoking C/C++ helpers.
    HHVM_C = 82,
    /// X86_INTR - x86 hardware interrupt context. Callee may take one or two
    /// parameters, where the 1st represents a pointer to hardware context frame
    /// and the 2nd represents hardware error code, the presence of the later
    /// depends on the interrupt vector taken. Valid for both 32- and 64-bit
    /// subtargets.
    X86_INTR = 83,
    /// Used for AVR interrupt routines.
    AVR_INTR = 84,
    /// Calling convention used for AVR signal routines.
    AVR_SIGNAL = 85,
    /// Calling convention used for special AVR rtlib functions
    /// which have an "optimized" convention to preserve registers.
    AVR_BUILTIN = 86,
    /// Calling convention used for Mesa vertex shaders, or AMDPAL last shader
    /// stage before rasterization (vertex shader if tessellation and geometry
    /// are not in use, or otherwise copy shader if one is needed).
    AMDGPU_VS = 87,
    /// Calling convention used for Mesa/AMDPAL geometry shaders.
    AMDGPU_GS = 88,
    /// Calling convention used for Mesa/AMDPAL pixel shaders.
    AMDGPU_PS = 89,
    /// Calling convention used for Mesa/AMDPAL compute shaders.
    AMDGPU_CS = 90,
    /// Calling convention for AMDGPU code object kernels.
    AMDGPU_KERNEL = 91,
    /// Register calling convention used for parameters transfer optimization
    X86_RegCall = 92,
    /// Calling convention used for Mesa/AMDPAL hull shaders (= tessellation
    /// control shaders).
    AMDGPU_HS = 93,
    /// Calling convention used for special MSP430 rtlib functions
    /// which have an "optimized" convention using additional registers.
    MSP430_BUILTIN = 94,
    /// Calling convention used for AMDPAL vertex shader if tessellation is in
    /// use.
    AMDGPU_LS = 95,
    /// Calling convention used for AMDPAL shader stage before geometry shader
    /// if geometry is in use. So either the domain (= tessellation evaluation)
    /// shader if tessellation is in use, or otherwise the vertex shader.
    AMDGPU_ES = 96,
    // Calling convention between AArch64 Advanced SIMD functions
    AArch64_VectorCall = 97,
    /// Calling convention between AArch64 SVE functions
    AArch64_SVE_VectorCall = 98,
    /// Calling convention for emscripten __invoke_* functions. The first
    /// argument is required to be the function ptr being indirectly called.
    /// The remainder matches the regular calling convention.
    WASM_EmscriptenInvoke = 99,
    /// Calling convention used for AMD graphics targets.
    AMDGPU_Gfx = 100,
    /// M68k_INTR - Calling convention used for M68k interrupt routines.
    M68k_INTR = 101,
    /// The highest possible calling convention ID. Must be some 2^k - 1.
    MaxID = 1023
}
enum 标识符分类_ : long {
    标识符_ = 0L,
    元数据标识符_ = 1L,
    函数名称_ = 2L,
    全局标识符_ = 4L,
    特性标识符_ = 8L,
    封装标识符_ = 16L,
    局部标识符_ = 32L,
    摘要标识符_ = 64L,
    标签标识符_ = 128L,
    类型标识符_ = 256L,
    文本内容标识符_ = 512L,
    全局变量标识符_ = 1024L,
    整数类型_ = 2048L,
    ID标识符_ = 4096L
}
enum 类型标志_ : long {
    无_ = 0L,
    内置类型_ = 1L,
    派生类型_ = 2L,
    特性声明_ = 4L,
    封装声明_ = 8L,
    是压缩的_ = 8589934592L,
    是不透明的_ = 17179869184L,
    可扩展的_ = 34359738368L,
    SCDB_IsSized = 68719476736L
}
enum TypeID_ : long {
    // PrimitiveTypes
    HalfTyID = 0L,
    BFloatTyID = 1L,
    FloatTyID = 2L,
    DoubleTyID = 3L,
    X86_FP80TyID = 4L,
    FP128TyID = 5L,
    PPC_FP128TyID = 6L,
    VoidTyID = 7L,
    LabelTyID = 8L,
    MetadataTyID = 9L,
    X86_MMXTyID = 10L,
    X86_AMXTyID = 11L,
    TokenTyID = 12L,
    // Derived types... see DerivedTypes.h file.
    IntegerTyID = 13L,
    FunctionTyID = 14L,
    PointerTyID = 15L,
    StructTyID = 16L,
    ArrayTyID = 17L,
    FixedVectorTyID = 18L,
    ScalableVectorTyID = 19L ///< Scalable SIMD vector type
    ,
    未知类型_ = 20L
}
enum ValIdKind_ : int {
    t_LocalID = 0,
    t_GlobalID = 1,
    t_LocalName = 2,
    t_GlobalName = 3,
    t_APSInt = 4,
    t_APFloat = 5,
    t_Null = 6,
    t_Undef = 7,
    t_Zero = 8,
    t_None = 9,
    t_Poison = 10,
    t_EmptyArray = 11,
    t_Constant = 12,
    t_InlineAsm = 13,
    t_ConstantStruct = 14,
    t_PackedConstantStruct = 15 // Value in ConstantStructElts.
}
enum MetadataKind_ : int {
    MDStringKind = 0,
    ConstantAsMetadataKind = 1,
    LocalAsMetadataKind = 2,
    DistinctMDOperandPlaceholderKind = 3,
    MDTupleKind = 4,
    DILocationKind = 5,
    DIExpressionKind = 6,
    DIGlobalVariableExpressionKind = 7,
    GenericDINodeKind = 8,
    DISubrangeKind = 9,
    DIEnumeratorKind = 10,
    DIBasicTypeKind = 11,
    DIDerivedTypeKind = 12,
    DICompositeTypeKind = 13,
    DISubroutineTypeKind = 14,
    DIFileKind = 15,
    DICompileUnitKind = 16,
    DISubprogramKind = 17,
    DILexicalBlockKind = 18,
    DILexicalBlockFileKind = 19,
    DINamespaceKind = 20,
    DIModuleKind = 21,
    DITemplateTypeParameterKind = 22,
    DITemplateValueParameterKind = 23,
    DIGlobalVariableKind = 24,
    DILocalVariableKind = 25,
    DILabelKind = 26,
    DIObjCPropertyKind = 27,
    DIImportedEntityKind = 28,
    DIMacroKind = 29,
    DIMacroFileKind = 30,
    DICommonBlockKind = 31,
    DIArgListKind = 32,
    DIStringTypeKind = 33,
    DIGenericSubrangeKind = 34,
    MetadataAsValueKind = 35,
    无效值_ = 36
}
enum MDID_ : int {
    MD_dbg = 0,
    MD_tbaa = 1,
    MD_prof = 2,
    MD_fpmath = 3,
    MD_range = 4,
    MD_tbaa_struct = 5,
    MD_invariant_load = 6,
    MD_alias_scope = 7,
    MD_noalias = 8,
    MD_nontemporal = 9,
    MD_mem_parallel_loop_access = 10,
    MD_nonnull = 11,
    MD_dereferenceable = 12,
    MD_dereferenceable_or_null = 13,
    MD_make_implicit = 14,
    MD_unpredictable = 15,
    MD_invariant_group = 16,
    MD_align = 17,
    MD_loop = 18,
    MD_type = 19,
    MD_section_prefix = 20,
    MD_absolute_symbol = 21,
    MD_associated = 22,
    MD_callees = 23,
    MD_irr_loop = 24,
    MD_access_group = 25,
    MD_callback = 26,
    MD_preserve_access_index = 27,
    MD_vcall_visibility = 28,
    MD_noundef = 29,
    MD_annotation = 30
}
enum LinkageTypes : int {
    ExternalLinkage = 0,
    AvailableExternallyLinkage = 1,
    LinkOnceAnyLinkage = 2,
    LinkOnceODRLinkage = 3,
    WeakAnyLinkage = 4,
    WeakODRLinkage = 5,
    AppendingLinkage = 6,
    InternalLinkage = 7,
    PrivateLinkage = 8,
    ExternalWeakLinkage = 9,
    CommonLinkage = 10 ///< Tentative definitions.
    ,
    无效值_ = 11
}
/// An enumeration for the kinds of visibility of global values.
enum VisibilityTypes : int {
    DefaultVisibility = 0,
    HiddenVisibility = 1,
    ProtectedVisibility = 2 ///< The GV is protected
}
/// Storage classes of global values for PE targets.
enum DLLStorageClassTypes : int {
    DefaultStorageClass = 0,
    DLLImportStorageClass = 1,
    DLLExportStorageClass = 2 ///< Function to be accessible from DLL.
}
enum UnnamedAddr : int {
    None = 0,
    Local = 1,
    Global = 2
}
enum SelectionKind : int {
    Any = 0,
    ExactMatch = 1,
    Largest = 2,
    NoDeduplicate = 3,
    SameSize = 4
}
enum 整数类型位数范围_ : uint {
    MIN_INT_BITS = 1u,
    MAX_INT_BITS = 8388608u
}
enum AtomicOrdering_ : int {
    NotAtomic = 0,
    Unordered = 1,
    Monotonic = 2,
    // Consume = 3,  // Not specified yet.
    Acquire = 4,
    Release = 5,
    AcquireRelease = 6,
    SequentiallyConsistent = 7,
    LAST = 7
}
enum ValueTy_ : int {
    无_ = 0,
    FunctionVal = 1,
    GlobalAliasVal = 2,
    GlobalIFuncVal = 3,
    GlobalVariableVal = 4,
    BlockAddressVal = 5,
    ConstantExprVal = 6,
    DSOLocalEquivalentVal = 7,
    ConstantArrayVal = 8,
    ConstantStructVal = 9,
    ConstantVectorVal = 10,
    UndefValueVal = 11,
    PoisonValueVal = 12,
    ConstantAggregateZeroVal = 13,
    ConstantDataArrayVal = 14,
    ConstantDataVectorVal = 15,
    ConstantIntVal = 16,
    ConstantFPVal = 17,
    ConstantPointerNullVal = 18,
    ConstantTokenNoneVal = 19,
    ArgumentVal = 20,
    BasicBlockVal = 21,
    MetadataAsValueVal = 22,
    InlineAsmVal = 23,
    MemoryUseVal = 24,
    MemoryDefVal = 25,
    MemoryPhiVal = 26,
    InstructionVal = 27,
    RetInstVal = 28,
    BranchInstVal = 29,
    SwitchInstVal = 30,
    IndirectBrInstVal = 31,
    InvokeInstVal = 32,
    ResumeInstVal = 33,
    CleanupRetVal = 34,
    CatchRetVal = 35,
    CatchSwitchVal = 36,
    CatchPadVar = 37,
    CleanupPadVar = 38,
    CallBrVal = 39,
    CallVal = 40,
    UnreachableInstVal = 41,
    FNegInstVal = 42,
    AddInstVal = 43,
    FAddInstVal = 44,
    SubInstVal = 45,
    FSubInstVal = 46,
    MulInstVal = 47,
    FMulInstVal = 48,
    UDivInstVal = 49,
    SDivInstVal = 50,
    FDivInstVal = 51,
    URemInstVal = 52,
    SRemInstVal = 53,
    FRemInstVal = 54,
    ShlInstVal = 55,
    LShrInstVal = 56,
    AShrInstVal = 57,
    AndInstVal = 58,
    OrInstVal = 59,
    XorInstVal = 60,
    AllocaInstVal = 61,
    LoadInstVal = 62,
    AtomicCmpXchgVal = 63,
    AtomicRMWVal = 64,
    FenceVal = 65,
    GetElementPtrVal = 66,
    ExtractValueVal = 67,
    InsertValueVal = 68,
    TruncInstVal = 69,
    ZExtInstVal = 70,
    SExtInstVal = 71,
    FPTruncInstVal = 72,
    FPExtInstVal = 73,
    BitCastInstVal = 74,
    AddrSpaceCastInstVal = 75,
    UIToFPInstVal = 76,
    SIToFPInstVal = 77,
    FPToUIInstVal = 78,
    FPToSIInstVal = 79,
    IntToPtrInstVal = 80,
    PtrToIntInstVal = 81,
    FCmpInstVal = 82,
    ICmpInstVal = 83,
    VAArgVal = 84,
    ExtractElementVar = 85,
    InsertElementVar = 86,
    ShuffleVectorVar = 87,
    PHIVar = 88,
    LandingPadVar = 89,
    FreezeVal = 90,
    形参值_ = 91,
    特性组_ = 92,
    特性值_ = 93,
    封装值_ = 94,
    元数据值_ = 95,
    三点值_ = 96,
    常量元素组_ = 97,
    对齐设置_ = 98,
    地址空间设置_ = 99,
    同步范围设置_ = 100,
    函数体_ = 101,
    MDVal = 102,
    ConstantFirstVal = 1,
    ConstantLastVal = 19,
    ConstantDataFirstVal = 11,
    ConstantDataLastVal = 19,
    ConstantAggregateFirstVal = 8,
    ConstantAggregateLastVal = 10
}
enum OverflowingBinaryOperator_ : int {
    AnyWrap = 0,
    NoUnsignedWrap = 1,
    NoSignedWrap = 2
}
enum PossiblyExactOperator_ : int {
    无_ = 0,
    IsExact = 1
}
enum CmpInst_Predicate_ : uint {
    // Opcode            U L G E    Intuitive operation
    FCMP_FALSE = 0u,
    FCMP_OEQ = 1u,
    FCMP_OGT = 2u,
    FCMP_OGE = 3u,
    FCMP_OLT = 4u,
    FCMP_OLE = 5u,
    FCMP_ONE = 6u,
    FCMP_ORD = 7u,
    FCMP_UNO = 8u,
    FCMP_UEQ = 9u,
    FCMP_UGT = 10u,
    FCMP_UGE = 11u,
    FCMP_ULT = 12u,
    FCMP_ULE = 13u,
    FCMP_UNE = 14u,
    FCMP_TRUE = 15u,
    FIRST_FCMP_PREDICATE = 0u,
    LAST_FCMP_PREDICATE = 15u,
    BAD_FCMP_PREDICATE = 16u,
    ICMP_EQ = 32u,
    ICMP_NE = 33u,
    ICMP_UGT = 34u,
    ICMP_UGE = 35u,
    ICMP_ULT = 36u,
    ICMP_ULE = 37u,
    ICMP_SGT = 38u,
    ICMP_SGE = 39u,
    ICMP_SLT = 40u,
    ICMP_SLE = 41u,
    BAD_ICMP_PREDICATE = 42u // ICMP_SLE + 1
    ,
    FIRST_ICMP_PREDICATE = 32u,
    LAST_ICMP_PREDICATE = 41u,
    无效值_ = 43u
}
enum InstructionKind_ : uint {
    无_ = 0u,
    Ret = 1u,
    Br = 2u,
    Switch = 3u,
    IndirectBr = 4u,
    Invoke = 5u,
    Resume = 6u,
    Unreachable = 7u,
    CleanupRet = 8u,
    CatchRet = 9u,
    CatchSwitch = 10u,
    CallBr = 11u,
    FNeg = 12u,
    Add = 13u,
    FAdd = 14u,
    Sub = 15u,
    FSub = 16u,
    Mul = 17u,
    FMul = 18u,
    UDiv = 19u,
    SDiv = 20u,
    FDiv = 21u,
    URem = 22u,
    SRem = 23u,
    FRem = 24u,
    Shl = 25u,
    LShr = 26u,
    AShr = 27u,
    And = 28u,
    Or = 29u,
    Xor = 30u,
    Alloca = 31u,
    Load = 32u,
    Store = 33u,
    GetElementPtr = 34u,
    Fence = 35u,
    AtomicCmpXchg = 36u,
    AtomicRMW = 37u,
    Trunc = 38u,
    ZExt = 39u,
    SExt = 40u,
    FPToUI = 41u,
    FPToSI = 42u,
    UIToFP = 43u,
    SIToFP = 44u,
    FPTrunc = 45u,
    FPExt = 46u,
    PtrToInt = 47u,
    IntToPtr = 48u,
    BitCast = 49u,
    AddrSpaceCast = 50u,
    CleanupPad = 51u,
    CatchPad = 52u,
    ICmp = 53u,
    FCmp = 54u,
    PHI = 55u,
    Call = 56u,
    Select = 57u,
    UserOp1 = 58u,
    UserOp2 = 59u,
    VAArg = 60u,
    ExtractElement = 61u,
    InsertElement = 62u,
    ShuffleVector = 63u,
    ExtractValue = 64u,
    InsertValue = 65u,
    LandingPad = 66u,
    Freeze = 67u,
    TermOpsBegin = 1u,
    TermOpsEnd = 12u,
    CastOpsBegin = 38u,
    CastOpsEnd = 51u,
    UnaryOpsBegin = 12u,
    UnaryOpsEnd = 13u,
    BinaryOpsBegin = 13u,
    BinaryOpsEnd = 31u,
    无效值_ = 99u
}
enum ValueField_ : int {
    AlignmentField = 6,
    UsedWithInAllocaField = 7,
    SwiftErrorField = 8
}
enum FastMathFlags_ : int {
    无效值_ = 0,
    AllowReassoc = 1,
    NoNaNs = 2,
    NoInfs = 4,
    NoSignedZeros = 8,
    AllowReciprocal = 16,
    AllowContract = 32,
    ApproxFunc = 64
}
enum TailCallKind_ : uint {
    TCK_None = 0u,
    TCK_Tail = 1u,
    TCK_MustTail = 2u,
    TCK_NoTail = 3u,
    TCK_LAST = 3u
}
enum AtomicRMWInstBinOp_ : uint {
    /// *p = v
    Xchg = 0u,
    /// *p = old + v
    Add = 1u,
    /// *p = old - v
    Sub = 2u,
    /// *p = old & v
    And = 3u,
    /// *p = ~(old & v)
    Nand = 4u,
    /// *p = old | v
    Or = 5u,
    /// *p = old ^ v
    Xor = 6u,
    /// *p = old >signed v ? old : v
    Max = 7u,
    /// *p = old <signed v ? old : v
    Min = 8u,
    /// *p = old >unsigned v ? old : v
    UMax = 9u,
    /// *p = old <unsigned v ? old : v
    UMin = 10u,
    /// *p = old + v
    FAdd = 11u,
    /// *p = old - v
    FSub = 12u,
    FIRST_BINOP = 0u,
    LAST_BINOP = 12u,
    BAD_BINOP = 13u
}
enum ThreadLocalMode_ : int {
    NotThreadLocal = 0,
    GeneralDynamicTLSModel = 1,
    LocalDynamicTLSModel = 2,
    InitialExecTLSModel = 3,
    LocalExecTLSModel = 4
}
enum 特性种类_ : int {
    无_ = 0,
    枚举特性_ = 1,
    整数特性_ = 2,
    对齐特性_ = 3,
    文本特性_ = 4,
    类型特性_ = 5
}
enum AsmDialect : int {
    AD_ATT = 0,
    AD_Intel = 1
}
enum StorageType_ : int {
    Uniqued = 0,
    Distinct = 1,
    Temporary = 2
}
enum 符号标志_ : long {
    无_ = 0L,
    类型声明_ = 1L,
    函数定义_ = 2L,
    函数声明_ = 4L,
    全局变量_ = 8L,
    别名声明_ = 16L,
    封装声明_ = 32L,
    命名元数据_ = 64L,
    独立元数据_ = 128L,
    特性声明_ = 256L,
    摘要声明_ = 512L,
    形参声明_ = 1024L,
    局部变量_ = 2048L,
    块声明_ = 4096L,
    结构字面量_ = 8192L,
    全局或局部值_ = 7198L,
    附件值_ = 992L,
    值_ = 8190L,
    类型_ = 8193L,
    全部_ = 16383L,
    有成员_ = 6L,
    局部变量排除_ = 16383L,
    函数排除_ = 30L,
    全局变量排除_ = 30L,
    封装排除_ = 32L,
    元数据排除_ = 192L,
    特性声明排除_ = 256L,
    类型名排除_ = 8193L,
    摘要声明排除_ = 512L
}
class IR类型_ : 类型_ {
    TypeID_ 种类;
    uint 位数;
    this() { }
    this(long 标志) {
        super(TK.Ir, 标志);
        this.位数 = ··null!(uint);
        this.种类 = TypeID_.未知类型_;
    }
}
class 指针类型_ : IR类型_ {
    IR类型_ 类型;
    uint 地址;
    this() { }
    this(IR类型_ 类型, uint 地址) {
        super((cast(整数_)(类型标志_.内置类型_)));
        this.种类 = TypeID_.PointerTyID;
        this.类型 = 类型;
        this.地址 = 地址;
    }
}
class 结构类型_ : IR类型_ {
    dstring 名称;
    bool 是压缩的;
    bool 是不透明的;
    IR类型_[] ContainedTys;
    this(符号_ 符号, bool 是压缩的 = false) {
        this.符号 = 符号;
        this.名称 = ··null!(dstring);
        this.是压缩的 = 是压缩的;
        this.ContainedTys = ··null!(IR类型_[]);
        if (符号 is ··null!(符号_)) {
            this.是不透明的 = true;
        }
        else {
            this.是不透明的 = false;
        }
    }
    this() {
        this.符号 = ··null!(符号_);
        this.名称 = ··null!(dstring);
        this.是压缩的 = false;
        this.ContainedTys = ··null!(IR类型_[]);
        this.是不透明的 = false;
    }
}
class 向量类型_ : IR类型_ {
    bool 可扩展的;
    IR类型_ 元素类型;
    uint 数量;
    this() { }
    this(IR类型_ 元素类型, bool 可扩展的, uint 数量) {
        super((cast(整数_)(类型标志_.派生类型_)));
        this.种类 = 可扩展的 ? TypeID_.ScalableVectorTyID : TypeID_.FixedVectorTyID;
        this.元素类型 = 元素类型;
        this.可扩展的 = 可扩展的;
        this.数量 = 数量;
    }
}
class 数组类型_ : IR类型_ {
    IR类型_ 元素类型;
    ulong 数量;
    this() { }
    this(IR类型_ 元素类型, ulong 数量) {
        super((cast(整数_)(类型标志_.派生类型_)));
        this.种类 = TypeID_.ArrayTyID;
        this.元素类型 = 元素类型;
        this.数量 = 数量;
    }
}
class 整数类型_ : IR类型_ {
    this() { }
    this(uint 位数) {
        super((cast(整数_)(类型标志_.派生类型_)));
        this.种类 = TypeID_.IntegerTyID;
        this.位数 = 位数;
    }
}
class 函数类型_ : IR类型_ {
    IR类型_ 返回类型;
    IR类型_[] 参数组;
    bool IsVarArg;
    this() { }
    this(IR类型_ 返回类型, IR类型_[] 参数组, bool IsVarArg) {
        super((cast(整数_)(类型标志_.派生类型_)));
        this.种类 = TypeID_.FunctionTyID;
        this.返回类型 = 返回类型;
        this.参数组 = 参数组;
        this.IsVarArg = IsVarArg;
    }
}
class 固定向量类型_ : 向量类型_ {
    this() { }
}
class 可扩展向量类型_ : 向量类型_ {
    this() { }
}
class SValue {
    IR符号_ 符号;
    this() { }
    this(IR符号_ 符号) {
        this.符号 = 符号;
    }
}
class Value {
    long id;
    ValueTy_ 种类;
    IR类型_ 类型;
    Value[] Ops;
    IR符号_ 解析符号;
    ulong SubclassOptionalData;
    this() {
        this.种类 = ValueTy_.无_;
        this.类型 = ··null!(IR类型_);
        this.解析符号 = ··null!(IR符号_);
        this.id = 0;
        this.Ops = ··null!(Value[]);
        this.SubclassOptionalData = 0;
    }
}
class 函数体 : Value {
    this() { }
    this(BasicBlock[] BBS) {
        super();
        this.种类 = ValueTy_.函数体_;
        this.Ops = cast(Value[])(BBS);
    }
}
class 元数据值_ : Value {
    IR符号_ 符号;
    this() { }
    this(IR符号_ 符号) {
        super();
        this.种类 = ValueTy_.元数据值_;
        this.符号 = 符号;
    }
}
class 对齐设置_ : Value {
    Align_ Val;
    this() { }
    this(ulong 值_) {
        super();
        this.种类 = ValueTy_.对齐设置_;
        this.Val = new Align_(值_);
    }
}
class 地址空间设置_ : Value {
    uint Val;
    this() { }
    this(uint 值_) {
        super();
        this.种类 = ValueTy_.地址空间设置_;
        this.Val = 值_;
    }
}
class 同步范围设置_ : Value {
    ubyte Val;
    this() { }
    this(ubyte 值_) {
        super();
        this.种类 = ValueTy_.地址空间设置_;
        this.Val = 值_;
    }
}
class 特性_ : Value {
    特性种类_ 特性种类;
    特性_ 解析特性;
    this() {
        super();
        this.种类 = ValueTy_.特性值_;
        this.特性种类 = 特性种类_.无_;
        this.解析特性 = ··null!(特性_);
    }
}
class 枚举特性_ : 特性_ {
    AttrKind_ 值;
    this() {
        super();
        this.特性种类 = 特性种类_.枚举特性_;
        this.值 = AttrKind_.None;
    }
}
class 整数特性_ : 特性_ {
    AttrKind_ 键;
    ulong 值;
    this() {
        super();
        this.特性种类 = 特性种类_.整数特性_;
        this.键 = AttrKind_.None;
        this.值 = ··null!(ulong);
    }
}
class 对齐特性_ : 特性_ {
    AttrKind_ 键;
    Align_ 值;
    this() {
        super();
        this.特性种类 = 特性种类_.对齐特性_;
        this.键 = AttrKind_.None;
        this.值 = ··null!(Align_);
    }
}
class 文本特性_ : 特性_ {
    dstring 键;
    dstring 值;
    this() {
        super();
        this.特性种类 = 特性种类_.文本特性_;
        this.键 = ··null!(dstring);
        this.值 = ··null!(dstring);
    }
}
class 类型特性_ : 特性_ {
    AttrKind_ 键;
    IR类型_ 值;
    this() {
        super();
        this.特性种类 = 特性种类_.类型特性_;
        this.键 = AttrKind_.None;
        this.值 = ··null!(IR类型_);
    }
}
class Argument : Value {
    特性组_ 特性组;
    this() {
        super();
        this.种类 = ValueTy_.ArgumentVal;
        this.特性组 = ··null!(特性组_);
        this.类型 = ··null!(IR类型_);
    }
}
class 三点值_ : Value {
    this() {
        super();
        this.种类 = ValueTy_.三点值_;
    }
}
class UnreachableInst : Instruction {
    this() {
        super();
        this.种类 = ValueTy_.UnreachableInstVal;
        this.Opc = InstructionKind_.Unreachable;
    }
    this(IR类型_ Ty) {
        this();
        this.类型 = Ty;
    }
}
class RetInst : Instruction {
    this() {
        super();
        this.种类 = ValueTy_.RetInstVal;
        this.Opc = InstructionKind_.Ret;
    }
    this(IR类型_ Ty, Value V = ··null!(Value)) {
        this();
        this.类型 = Ty;
        if (V !is ··null!(Value)) {
            this.Ops.length = 1;
            this.Ops[0] = V;
        }
    }
}
class BranchInst : Instruction {
    this() {
        super();
        this.种类 = ValueTy_.BranchInstVal;
        this.Opc = InstructionKind_.Br;
    }
    this(IR类型_ Ty, BasicBlock IfTrue, BasicBlock IfFalse = ··null!(BasicBlock), Value Cond = ··null!(Value)) {
        this();
        this.类型 = Ty;
        if ((IfFalse !is ··null!(BasicBlock)) && (Cond !is ··null!(Value))) {
            this.Ops.length = 3;
        }
        else {
            this.Ops.length = 1;
        }
        if (Cond !is ··null!(Value)) {
            this.Ops[0] = Cond;
            this.Ops[1] = IfFalse;
            this.Ops[2] = IfTrue;
        }
        else {
            this.Ops[0] = IfTrue;
        }
    }
}
class 跳转表_ {
    ConstantInt Constant;
    BasicBlock DestBB;
    this() { }
    this(ConstantInt C, BasicBlock B) {
        this.Constant = C;
        this.DestBB = B;
    }
}
class SwitchInst : Instruction {
    this() {
        super();
        this.种类 = ValueTy_.SwitchInstVal;
        this.Opc = InstructionKind_.Switch;
    }
    this(IR类型_ Ty, Value Cond, BasicBlock DefaultBB, 跳转表_[] Table) {
        this();
        this.类型 = Ty;
        this.Ops.length = 2 + Table.length * 2;
        this.Ops[0] = Cond;
        this.Ops[1] = DefaultBB;
        {
            int i = 0;
            int ii = 1;
            for (; i < Table.length; ++i, ii += 2) {
                跳转表_ T = Table[i];
                this.Ops[ii] = T.Constant;
                this.Ops[ii + 1] = T.DestBB;
            }
        }
    }
}
class IndirectBrInst : Instruction {
    this() {
        super();
        this.种类 = ValueTy_.IndirectBrInstVal;
        this.Opc = InstructionKind_.IndirectBr;
    }
    this(IR类型_ Ty, Value Address, BasicBlock[] DestList) {
        this();
        this.类型 = Ty;
        this.Ops.length = 1 + DestList.length;
        this.Ops[0] = Address;
        {
            for (int i = 0; i < DestList.length; ++i) {
                this.Ops[i + 1] = DestList[i];
            }
        }
    }
}
class CallBase : Instruction {
    函数类型_ FTy;
    Align_ 对齐;
    特性组_[] 特性组;
    CallingConv_ CC;
    this() {
        super();
        this.对齐 = ··null!(Align_);
        this.特性组 = ··null!(特性组_[]);
        this.CC = CallingConv_.C;
        this.FTy = ··null!(函数类型_);
    }
    Function getFunc() {
        return (cast(Function)(this.Ops[this.Ops.length - 1]));
    }
}
class InvokeInst : CallBase {
    函数类型_ FTy;
    this() {
        super();
        this.种类 = ValueTy_.InvokeInstVal;
        this.Opc = InstructionKind_.Invoke;
        this.FTy = ··null!(函数类型_);
    }
    this(函数类型_ FTy, Value Fn, BasicBlock IfNormal, BasicBlock IfException, Value[] Args, BundleDef[] Bundles, 特性组_[] 特性组, Align_ 对齐, CallingConv_ CC) {
        this();
        this.类型 = FTy.返回类型;
        this.FTy = FTy;
        this.Ops.length = Args.length + Bundles.length + 3;
        int i = 0;
        for (; i < Args.length; ++i) {
            Value a = Args[i];
            this.Ops[i] = a;
        }
        int bi = 0;
        for (; bi < Bundles.length; ++bi) {
            BundleDef a = Bundles[bi];
            this.Ops[i + bi] = a;
        }
        this.Ops[this.Ops.length - 3] = IfNormal;
        this.Ops[this.Ops.length - 2] = IfException;
        this.Ops[this.Ops.length - 1] = Fn;
        this.特性组 = 特性组;
        this.CC = CC;
        this.对齐 = 对齐;
    }
}
class CallBrInst : CallBase {
    this() {
        super();
        this.种类 = ValueTy_.CallBrVal;
        this.Opc = InstructionKind_.CallBr;
        this.FTy = ··null!(函数类型_);
    }
    this(函数类型_ Ty, Value Fn, BasicBlock DefaultDest, BasicBlock[] IndirectDests, Value[] Args, BundleDef[] Bundles, 特性组_[] 特性组, Align_ 对齐, CallingConv_ CC) {
        this();
        this.类型 = Ty.返回类型;
        this.FTy = Ty;
        .追加!(Value)(this.Ops, DefaultDest);
        .追加!(Value)(this.Ops, Args);
        .追加!(Value)(this.Ops, cast(Value[])(IndirectDests));
        .追加!(Value)(this.Ops, cast(Value[])(Bundles));
        .追加!(Value)(this.Ops, Fn);
    }
}
class CallInst : CallBase {
    FastMathFlags_ FMF;
    TailCallKind_ TCK;
    this() {
        super();
        this.种类 = ValueTy_.CallVal;
        this.Opc = InstructionKind_.Call;
        this.FMF = FastMathFlags_.无效值_;
        this.TCK = TailCallKind_.TCK_None;
    }
    this(函数类型_ Ty, Value Fn, Value[] Args, BundleDef[] Bundles, 特性组_[] 特性组, Align_ 对齐, CallingConv_ CC, FastMathFlags_ FMF, TailCallKind_ TCK) {
        this();
        this.类型 = Ty.返回类型;
        this.FTy = Ty;
        this.FMF = FMF;
        this.TCK = TCK;
        .追加!(Value)(this.Ops, Args);
        .追加!(Value)(this.Ops, cast(Value[])(Bundles));
        .追加!(Value)(this.Ops, Fn);
    }
}
class ResumeInst : Instruction {
    this() { }
    this(Value V = ··null!(Value)) {
        super();
        this.种类 = ValueTy_.ResumeInstVal;
        this.Opc = InstructionKind_.Resume;
        if (V !is ··null!(Value)) {
            .追加!(Value)(this.Ops, V);
        }
    }
}
class CleanupReturnInst : Instruction {
    this() { }
    this(IR类型_ Ty, Value CleanupPad, BasicBlock UnwindBB = ··null!(BasicBlock)) {
        super();
        this.种类 = ValueTy_.CleanupRetVal;
        this.Opc = InstructionKind_.CleanupRet;
        this.类型 = Ty;
        this.Ops.length = 1;
        this.Ops[0] = CleanupPad;
        if (UnwindBB !is ··null!(BasicBlock)) {
            this.Ops.length = 2;
            this.Ops[1] = UnwindBB;
        }
    }
}
class CatchReturnInst : Instruction {
    this() { }
    this(IR类型_ Ty, Value CatchPad, BasicBlock BB) {
        super();
        this.种类 = ValueTy_.CatchRetVal;
        this.Opc = InstructionKind_.CatchRet;
        this.类型 = Ty;
        this.Ops.length = 2;
        this.Ops[0] = CatchPad;
        this.Ops[1] = BB;
    }
}
class CatchSwitchInst : Instruction {
    this() { }
    this(IR类型_ Ty, Value ParentPad, BasicBlock[] Table, BasicBlock UnwindDest = ··null!(BasicBlock)) {
        super();
        this.种类 = ValueTy_.CatchSwitchVal;
        this.Opc = InstructionKind_.CatchSwitch;
        this.类型 = Ty;
        this.Ops.length = 1;
        this.Ops[0] = ParentPad;
        if (UnwindDest !is ··null!(BasicBlock)) {
            this.Ops.length = 2;
            this.Ops[1] = UnwindDest;
        }
        foreach (BasicBlock T; Table) {
            .追加!(Value)(this.Ops, T);
        }
    }
}
class FuncletPadInst : Instruction {
    this() { }
    this(ValueTy_ 种类) {
        super();
        this.种类 = 种类;
        this.Opc = 种类 == ValueTy_.CatchPadVar ? InstructionKind_.CatchPad : InstructionKind_.CleanupPad;
    }
}
class CleanupPadInst : FuncletPadInst {
    this() { }
    this(Value ParentPad, Value[] Args) {
        super(ValueTy_.CleanupPadVar);
        this.类型 = ParentPad.类型;
        .追加!(Value)(this.Ops, Args);
        .追加!(Value)(this.Ops, ParentPad);
    }
}
class CatchPadInst : FuncletPadInst {
    this() { }
    this(Value CatchSwitch, Value[] Args) {
        super(ValueTy_.CatchPadVar);
        this.类型 = CatchSwitch.类型;
        .追加!(Value)(this.Ops, Args);
        .追加!(Value)(this.Ops, CatchSwitch);
    }
}
class AllocaInst : Instruction {
    Align_ 对齐;
    类型_ AllocatedType;
    bool IsInAlloca;
    bool IsSwiftError;
    this() {
        super();
        this.种类 = ValueTy_.AllocaInstVal;
        this.Opc = InstructionKind_.Alloca;
        this.对齐 = ··null!(Align_);
        this.AllocatedType = ··null!(类型_);
        this.IsInAlloca = false;
        this.IsSwiftError = false;
    }
}
class LoadInst : Instruction {
    Align_ 对齐;
    bool isVolatile;
    ubyte SSID;
    AtomicOrdering_ OrderingField;
    this() {
        super();
        this.种类 = ValueTy_.LoadInstVal;
        this.Opc = InstructionKind_.Load;
        this.对齐 = ··null!(Align_);
        this.isVolatile = false;
        this.SSID = 1;
        this.OrderingField = AtomicOrdering_.NotAtomic;
    }
}
class AtomicCmpXchgInst : Instruction {
    Align_ 对齐;
    bool isVolatile;
    bool isWeak;
    ubyte SSID;
    AtomicOrdering_ SuccessOrdering;
    AtomicOrdering_ FailureOrdering;
    this() {
        super();
        this.种类 = ValueTy_.AtomicCmpXchgVal;
        this.Opc = InstructionKind_.AtomicCmpXchg;
        this.对齐 = ··null!(Align_);
        this.isVolatile = false;
        this.isWeak = false;
        this.SSID = 1;
        this.SuccessOrdering = AtomicOrdering_.NotAtomic;
        this.FailureOrdering = AtomicOrdering_.NotAtomic;
    }
}
class AtomicRMWInst : Instruction {
    Align_ 对齐;
    bool isVolatile;
    ubyte SSID;
    AtomicRMWInstBinOp_ Operation;
    AtomicOrdering_ Ordering;
    this() {
        super();
        this.种类 = ValueTy_.AtomicRMWVal;
        this.Opc = InstructionKind_.AtomicRMW;
        this.对齐 = ··null!(Align_);
        this.isVolatile = false;
        this.SSID = 1;
        this.Operation = AtomicRMWInstBinOp_.Xchg;
        this.Ordering = AtomicOrdering_.NotAtomic;
    }
}
class FenceInst : Instruction {
    ubyte SSID;
    AtomicOrdering_ Ordering;
    this() {
        super();
        this.种类 = ValueTy_.FenceVal;
        this.Opc = InstructionKind_.Fence;
        this.SSID = 1;
        this.Ordering = AtomicOrdering_.NotAtomic;
    }
}
class GetElementPtrInst : Instruction {
    bool InBounds;
    IR类型_ SourceElementType;
    IR类型_ ResultElementType;
    this() {
        super();
        this.种类 = ValueTy_.GetElementPtrVal;
        this.Opc = InstructionKind_.GetElementPtr;
        this.SourceElementType = ··null!(IR类型_);
        this.ResultElementType = ··null!(IR类型_);
        this.InBounds = false;
    }
}
class ExtractValueInst : Instruction {
    uint[] Indices;
    this() {
        super();
        this.种类 = ValueTy_.ExtractValueVal;
        this.Opc = InstructionKind_.ExtractValue;
        this.Indices = ··null!(uint[]);
    }
}
class InsertValueInst : Instruction {
    uint[] Indices;
    this() {
        super();
        this.种类 = ValueTy_.InsertValueVal;
        this.Opc = InstructionKind_.InsertValue;
        this.Indices = ··null!(uint[]);
    }
}
class UnaryInstruction : Instruction {
    this() { }
    this(ValueTy_ 种类, InstructionKind_ Opc) {
        super();
        this.种类 = 种类;
        this.Ops.length = 1;
        this.Opc = Opc;
    }
}
class VAArgInst : UnaryInstruction {
    this() { }
    this(IR类型_ Ty, Value List) {
        super(ValueTy_.VAArgVal, InstructionKind_.VAArg);
        this.类型 = Ty;
        this.Ops[0] = List;
    }
}
class ExtractElementInst : Instruction {
    this() { }
    this(IR类型_ Ty, Value Val, Value Index) {
        super();
        this.类型 = Ty;
        this.Opc = InstructionKind_.ExtractElement;
        this.种类 = ValueTy_.ExtractElementVar;
        this.Ops.length = 2;
        this.Ops[0] = Val;
        this.Ops[1] = Index;
    }
}
class InsertElementInst : Instruction {
    this() { }
    this(IR类型_ Ty, Value Val, Value NewElt, Value Index) {
        super();
        this.Opc = InstructionKind_.InsertElement;
        this.种类 = ValueTy_.InsertElementVar;
        this.类型 = Ty, this.Ops.length = 3;
        this.Ops[0] = Val;
        this.Ops[1] = NewElt;
        this.Ops[2] = Index;
    }
}
class ShuffleVectorInst : Instruction {
    int[] ShuffleMask;
    Constant ShuffleMaskForBitcode;
    this() {
        super();
        this.Opc = InstructionKind_.ShuffleVector;
        this.种类 = ValueTy_.ShuffleVectorVar;
        this.Ops.length = 2;
        this.ShuffleMask = ··null!(int[]);
        this.ShuffleMaskForBitcode = ··null!(Constant);
    }
}
class PHINode : Instruction {
    FastMathFlags_ FMF;
    this() {
        super();
        this.Opc = InstructionKind_.PHI;
        this.种类 = ValueTy_.PHIVar;
        this.FMF = FastMathFlags_.无效值_;
    }
}
class LandingPadInst : Instruction {
    bool Cleanup;
    this() {
        super();
        this.Opc = InstructionKind_.LandingPad;
        this.种类 = ValueTy_.LandingPadVar;
        this.Cleanup = false;
    }
}
class FreezeInst : UnaryInstruction {
    this() { }
    this(Value Op) {
        super(ValueTy_.FreezeVal, InstructionKind_.Freeze);
        this.类型 = Op.类型;
        this.Ops[0] = Op;
    }
}
class CastInst : UnaryInstruction {
    this() { }
    this(ValueTy_ 种类, InstructionKind_ Opc) {
        super(种类, Opc);
    }
}
class TruncInst : CastInst {
    this() {
        super(ValueTy_.TruncInstVal, InstructionKind_.Trunc);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class ZExtInst : CastInst {
    this() {
        super(ValueTy_.ZExtInstVal, InstructionKind_.ZExt);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class SExtInst : CastInst {
    this() {
        super(ValueTy_.SExtInstVal, InstructionKind_.SExt);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class FPTruncInst : CastInst {
    this() {
        super(ValueTy_.FPTruncInstVal, InstructionKind_.FPTrunc);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class FPExtInst : CastInst {
    this() {
        super(ValueTy_.FPExtInstVal, InstructionKind_.FPExt);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class BitCastInst : CastInst {
    this() {
        super(ValueTy_.BitCastInstVal, InstructionKind_.BitCast);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class AddrSpaceCastInst : CastInst {
    this() {
        super(ValueTy_.AddrSpaceCastInstVal, InstructionKind_.AddrSpaceCast);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class UIToFPInst : CastInst {
    this() {
        super(ValueTy_.UIToFPInstVal, InstructionKind_.UIToFP);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class SIToFPInst : CastInst {
    this() {
        super(ValueTy_.SIToFPInstVal, InstructionKind_.SIToFP);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class FPToUIInst : CastInst {
    this() {
        super(ValueTy_.FPToUIInstVal, InstructionKind_.FPToUI);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class FPToSIInst : CastInst {
    this() {
        super(ValueTy_.FPToSIInstVal, InstructionKind_.FPToSI);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class IntToPtrInst : CastInst {
    this() {
        super(ValueTy_.IntToPtrInstVal, InstructionKind_.IntToPtr);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class PtrToIntInst : CastInst {
    this() {
        super(ValueTy_.PtrToIntInstVal, InstructionKind_.PtrToInt);
    }
    this(IR类型_ Ty, Value Op) {
        this();
        this.类型 = Ty;
        this.Ops[0] = Op;
    }
}
class BinaryOperator : Instruction {
    FastMathFlags_ FMF;
    bool Exact;
    this() {
        super();
        this.FMF = FastMathFlags_.无效值_;
        this.Exact = false;
    }
}
class AddInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.AddInstVal;
        this.Opc = InstructionKind_.Add;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class FAddInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.FAddInstVal;
        this.Opc = InstructionKind_.FAdd;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class SubInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.SubInstVal;
        this.Opc = InstructionKind_.Sub;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class FSubInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.FSubInstVal;
        this.Opc = InstructionKind_.FSub;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class MulInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.MulInstVal;
        this.Opc = InstructionKind_.Mul;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class FMulInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.FMulInstVal;
        this.Opc = InstructionKind_.FMul;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class UDivInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.UDivInstVal;
        this.Opc = InstructionKind_.UDiv;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class SDivInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.SDivInstVal;
        this.Opc = InstructionKind_.SDiv;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class FDivInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.FDivInstVal;
        this.Opc = InstructionKind_.FDiv;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class URemInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.URemInstVal;
        this.Opc = InstructionKind_.URem;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class SRemInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.SRemInstVal;
        this.Opc = InstructionKind_.SRem;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class FRemInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.FRemInstVal;
        this.Opc = InstructionKind_.FRem;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class ShlInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.ShlInstVal;
        this.Opc = InstructionKind_.Shl;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class LShrInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.LShrInstVal;
        this.Opc = InstructionKind_.LShr;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class AShrInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.AShrInstVal;
        this.Opc = InstructionKind_.AShr;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class AndInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.AndInstVal;
        this.Opc = InstructionKind_.And;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class OrInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.OrInstVal;
        this.Opc = InstructionKind_.Or;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class XorInst : BinaryOperator {
    this() {
        super();
        this.种类 = ValueTy_.XorInstVal;
        this.Opc = InstructionKind_.Xor;
    }
    this(Value L, Value R) {
        this();
        this.类型 = L.类型;
        this.Ops.length = 2;
        this.Ops[0] = L;
        this.Ops[1] = R;
    }
}
class CmpInst : Instruction {
    CmpInst_Predicate_ Pred;
    FastMathFlags_ FMF;
    this() { }
    this(ValueTy_ VT, InstructionKind_ IK) {
        super();
        this.种类 = VT;
        this.Opc = IK;
        this.Ops.length = 2;
        this.Pred = CmpInst_Predicate_.无效值_;
        this.FMF = FastMathFlags_.无效值_;
    }
}
class FCmpInst : CmpInst {
    this() {
        super(ValueTy_.FCmpInstVal, InstructionKind_.FCmp);
    }
    this(IR类型_ Ty, CmpInst_Predicate_ pred, Value LHS, Value RHS, FastMathFlags_ FMF = FastMathFlags_.无效值_) {
        this();
        this.类型 = Ty;
        this.Pred = pred;
        this.Ops[0] = LHS;
        this.Ops[1] = RHS;
        this.FMF = FMF;
    }
}
class ICmpInst : CmpInst {
    this() {
        super(ValueTy_.ICmpInstVal, InstructionKind_.ICmp);
    }
    this(IR类型_ Ty, CmpInst_Predicate_ pred, Value LHS, Value RHS, FastMathFlags_ FMF = FastMathFlags_.无效值_) {
        this();
        this.类型 = Ty;
        this.Pred = pred;
        this.Ops[0] = LHS;
        this.Ops[1] = RHS;
        this.FMF = FMF;
    }
}
class UnaryOperator : Instruction {
    FastMathFlags_ FMF;
    this() { }
    this(ValueTy_ VT, InstructionKind_ IK) {
        super();
        this.种类 = VT;
        this.Opc = IK;
        this.Ops.length = 1;
        this.FMF = FastMathFlags_.无效值_;
    }
}
class FNegInst : UnaryOperator {
    this() { }
    this(Value Op, FastMathFlags_ FMF = FastMathFlags_.无效值_) {
        super(ValueTy_.FNegInstVal, InstructionKind_.FNeg);
        this.类型 = Op.类型;
        this.Ops[0] = Op;
        this.FMF = FMF;
    }
}
class 特性组值_ : Value {
    特性组_ 特性组;
    this() {
        super();
        this.种类 = ValueTy_.特性组_;
        this.特性组 = ··null!(特性组_);
    }
    this(特性组_ attr) {
        super();
        this.种类 = ValueTy_.特性组_;
        this.特性组 = attr;
    }
}
class 常量元素组_ : Value {
    Constant[] Elts;
    this() {
        super();
        this.种类 = ValueTy_.常量元素组_;
        this.Elts = ··null!(Constant[]);
    }
    this(Constant[] Elts) {
        this();
        this.Elts = Elts;
    }
}
class 封装值_ : Value {
    SelectionKind 值;
    this() {
        super();
        this.种类 = ValueTy_.封装值_;
        this.值 = SelectionKind.Any;
    }
    this(SelectionKind 值) {
        super();
        this.种类 = ValueTy_.封装值_;
        this.值 = 值;
    }
}
class Instruction : Value {
    InstructionKind_ Opc;
    this() {
        super();
        this.种类 = ValueTy_.InstructionVal;
        this.Opc = InstructionKind_.无效值_;
    }
}
class BasicBlock : Value {
    符号_ 符号;
    this() {
        super();
        this.种类 = ValueTy_.BasicBlockVal;
        this.符号 = ··null!(符号_);
    }
}
class Constant : Value {
    bool isConstantGlobal;
    bool isExternallyInitializedConstant;
    this() {
        super();
        this.isConstantGlobal = false;
        this.isExternallyInitializedConstant = false;
    }
}
class GlobalValue : Constant {
    LinkageTypes Linkage;
    bool IsDSOLocal;
    UnnamedAddr UnnamedAddrVal;
    VisibilityTypes Visibility;
    Align_ Align;
    IR符号_ 符号;
    dstring Partition;
    DLLStorageClassTypes DllStorageClass;
    uint AddrSpace;
    ThreadLocalMode_ TLM;
    IR类型_ ValueType;
    this() {
        super();
        this.符号 = ··null!(IR符号_);
        this.Align = ··null!(Align_);
        this.Linkage = LinkageTypes.无效值_;
        this.IsDSOLocal = true;
        this.UnnamedAddrVal = UnnamedAddr.Global;
        this.Partition = ··null!(dstring);
        this.Visibility = VisibilityTypes.DefaultVisibility;
        this.DllStorageClass = DLLStorageClassTypes.DefaultStorageClass;
        this.AddrSpace = 0;
        this.TLM = ThreadLocalMode_.NotThreadLocal;
        this.ValueType = ··null!(IR类型_);
    }
}
class Module : GlobalValue {
    DataLayout DL;
    this() {
        super();
        this.DL = ··null!(DataLayout);
    }
}
class GlobalIndirectSymbol : GlobalValue {
    this() {
        super();
    }
}
class GlobalAlias : GlobalIndirectSymbol {
    this() {
        super();
        this.种类 = ValueTy_.GlobalAliasVal;
        this.Ops.length = 1;
    }
}
class GlobalIFunc : GlobalIndirectSymbol {
    this() {
        super();
        this.种类 = ValueTy_.GlobalIFuncVal;
        this.Ops.length = 1;
    }
}
class GlobalObject : GlobalValue {
    dstring Section;
    封装值_ ObjComdat;
    this() {
        super();
        this.Section = ··null!(dstring);
        this.ObjComdat = ··null!(封装值_);
    }
}
class Function : GlobalObject {
    特性组_[] 特性组;
    dstring GC;
    词典_!(BasicBlock) BasicBlocks;
    this() {
        super();
        this.种类 = ValueTy_.FunctionVal;
        this.特性组 = ··null!(特性组_[]);
        this.GC = ··null!(dstring);
        this.BasicBlocks = ··null!(词典_!(BasicBlock));
    }
}
class GlobalVariable : GlobalObject {
    IR符号_ 符号;
    特性组_[] 特性组;
    this() {
        super();
        this.种类 = ValueTy_.GlobalVariableVal;
        this.符号 = ··null!(IR符号_);
        this.特性组 = ··null!(特性组_[]);
        this.TLM = ThreadLocalMode_.NotThreadLocal;
    }
}
class BlockAddress : Constant {
    Function FN;
    BasicBlock BB;
    this() {
        super();
        this.种类 = ValueTy_.BlockAddressVal;
        this.FN = ··null!(Function);
        this.BB = ··null!(BasicBlock);
    }
    this(IR类型_ Ty, Function FN, BasicBlock BB) {
        this();
        this.类型 = Ty;
        this.FN = FN;
        this.BB = BB;
    }
}
class DSOLocalEquivalent : Constant {
    GlobalValue GV;
    this() {
        super();
        this.种类 = ValueTy_.DSOLocalEquivalentVal;
        this.GV = ··null!(GlobalValue);
    }
    this(GlobalValue GV) {
        this();
        this.类型 = GV.类型;
        this.GV = GV;
    }
}
class InlineAsm : Value {
    函数类型_ FTy;
    dstring AsmString;
    dstring Constraints;
    bool HasSideEffects;
    bool IsAlignStack;
    AsmDialect Dialect;
    bool CanThrow;
    this() {
        super();
        this.种类 = ValueTy_.InlineAsmVal;
        this.FTy = ··null!(函数类型_);
        this.AsmString = ··null!(dstring);
        this.Constraints = ··null!(dstring);
        this.HasSideEffects = false;
        this.IsAlignStack = false;
        this.Dialect = AsmDialect.AD_ATT;
        this.CanThrow = false;
    }
    this(dstring AsmString, dstring Constraints, bool HasSideEffects, bool IsAlignStack, AsmDialect Dialect, bool CanThrow) {
        super();
        this.种类 = ValueTy_.InlineAsmVal;
        this.FTy = ··null!(函数类型_);
        this.AsmString = AsmString;
        this.Constraints = Constraints;
        this.HasSideEffects = HasSideEffects;
        this.IsAlignStack = IsAlignStack;
        this.Dialect = Dialect;
        this.CanThrow = CanThrow;
    }
}
class ConstantData : Constant {
    this() {
        super();
    }
}
class ConstantInt : ConstantData {
    APInt_ Val;
    this() {
        super();
        this.种类 = ValueTy_.ConstantIntVal;
        this.Val = ··null!(APInt_);
    }
    this(IR类型_ Ty, APInt_ Val) {
        this();
        this.类型 = Ty;
        this.Val = Val;
    }
    this(IR类型_ Ty, ulong Val, bool isSig = false) {
        this();
        this.类型 = Ty;
        this.Val = new APInt_(Ty.位数, Val, isSig);
    }
}
class ConstantFP : ConstantData {
    APFloat_ Val;
    this() {
        super();
        this.种类 = ValueTy_.ConstantFPVal;
        this.Val = ··null!(APFloat_);
    }
    this(IR类型_ Ty, APFloat_ Val) {
        this();
        this.类型 = Ty;
        this.Val = Val;
    }
}
class ConstantPointerNull : ConstantData {
    this() {
        super();
        this.种类 = ValueTy_.ConstantPointerNullVal;
    }
    this(IR类型_ Ty) {
        this();
        this.类型 = Ty;
    }
}
class UndefValue : ConstantData {
    this() {
        super();
        this.种类 = ValueTy_.UndefValueVal;
    }
    this(IR类型_ Ty) {
        this();
        this.类型 = Ty;
    }
}
class PoisonValue : UndefValue {
    this() {
        super();
        this.种类 = ValueTy_.PoisonValueVal;
    }
    this(IR类型_ Ty) {
        this();
        this.类型 = Ty;
    }
}
class ConstantAggregateZero : ConstantData {
    this() {
        super();
        this.种类 = ValueTy_.ConstantAggregateZeroVal;
    }
    this(IR类型_ Ty) {
        this();
        this.类型 = Ty;
    }
}
class ConstantTokenNone : ConstantData {
    this() {
        super();
        this.种类 = ValueTy_.ConstantTokenNoneVal;
    }
    this(IR类型_ Ty) {
        this();
        this.类型 = Ty;
    }
}
class ConstantDataSequential : ConstantData {
    char[] DataElements;
    this() {
        super();
        this.DataElements = ··null!(char[]);
    }
    this(IR类型_ Ty, ValueTy_ ID) {
        super();
        this.类型 = Ty;
        this.种类 = ID;
        this.DataElements = ··null!(char[]);
    }
}
class ConstantDataArray : ConstantDataSequential {
    this() {
        super();
        this.种类 = ValueTy_.ConstantDataArrayVal;
    }
    this(IR类型_ Ty, char[] Data) {
        super(Ty, ValueTy_.ConstantDataArrayVal);
        this.DataElements = Data;
    }
}
class ConstantDataVector : ConstantDataSequential {
    this() {
        super();
        this.种类 = ValueTy_.ConstantDataVectorVal;
    }
    this(IR类型_ Ty, char[] Data) {
        super(Ty, ValueTy_.ConstantDataVectorVal);
        this.DataElements = Data;
    }
}
class ConstantAggregate : Constant {
    this() {
        super();
    }
    this(IR类型_ Ty, ValueTy_ ID) {
        super();
        this.类型 = Ty;
        this.种类 = ID;
    }
}
class ConstantStruct : ConstantAggregate {
    this() {
        super();
        this.种类 = ValueTy_.ConstantStructVal;
    }
    this(IR类型_ Ty, Constant[] Ops) {
        super(Ty, ValueTy_.ConstantStructVal);
        this.Ops = cast(Value[])(Ops);
    }
}
class ConstantArray : ConstantAggregate {
    this() {
        super();
        this.种类 = ValueTy_.ConstantArrayVal;
    }
    this(IR类型_ Ty, Constant[] Ops) {
        super(Ty, ValueTy_.ConstantArrayVal);
        this.Ops = cast(Value[])(Ops);
    }
}
class ConstantVector : ConstantAggregate {
    this() {
        super();
        this.种类 = ValueTy_.ConstantVectorVal;
    }
    this(IR类型_ Ty, Constant[] Ops) {
        super(Ty, ValueTy_.ConstantVectorVal);
        this.Ops = cast(Value[])(Ops);
    }
}
class ConstantExpr : Constant {
    InstructionKind_ Opc;
    this() {
        super();
        this.种类 = ValueTy_.ConstantExprVal;
        this.Opc = InstructionKind_.无_;
        this.SubclassOptionalData = 0;
    }
}
class ShuffleVectorConstantExpr : ConstantExpr {
    int[] Mask;
    this() {
        super();
        this.Opc = InstructionKind_.ShuffleVector;
        this.Mask = ··null!(int[]);
    }
    this(Constant C1, Constant C2, int[] Mask) {
        super();
        this.Opc = InstructionKind_.ShuffleVector;
        this.Mask = Mask;
        .追加!(Value)(this.Ops, C1, C2);
    }
}
class ExtractValueConstantExpr : ConstantExpr {
    uint[] Indices;
    this() {
        super();
        this.Opc = InstructionKind_.ExtractValue;
        this.Indices = ··null!(uint[]);
    }
    this(Constant Agg, uint[] Indices, IR类型_ DestTy) {
        super();
        this.Opc = InstructionKind_.ExtractValue;
        this.类型 = DestTy;
        this.Indices = Indices;
        .追加!(Value)(this.Ops, Agg);
    }
}
class InsertValueConstantExpr : ConstantExpr {
    uint[] Indices;
    this() {
        super();
        this.Opc = InstructionKind_.InsertValue;
        this.Indices = ··null!(uint[]);
    }
    this(Constant Agg, Constant Val, uint[] Indices, IR类型_ DestTy) {
        super();
        this.Opc = InstructionKind_.InsertValue;
        this.类型 = DestTy;
        this.Indices = Indices;
        .追加!(Value)(this.Ops, Agg, Val);
    }
}
class GetElementPtrConstantExpr : ConstantExpr {
    IR类型_ SrcElementTy;
    IR类型_ ResElementTy;
    this() {
        super();
        this.Opc = InstructionKind_.GetElementPtr;
        this.SrcElementTy = ··null!(IR类型_);
        this.ResElementTy = ··null!(IR类型_);
    }
}
class CompareConstantExpr : ConstantExpr {
    ubyte predicate;
    this() {
        super();
        this.Opc = InstructionKind_.ICmp;
        this.predicate = 0;
    }
    this(IR类型_ Ty, InstructionKind_ Opc, ubyte pred, Constant LHS, Constant RHS) {
        super();
        this.类型 = Ty;
        this.Opc = Opc;
        this.predicate = pred;
        .追加!(Value)(this.Ops, LHS, RHS);
    }
}
class UnaryConstantExpr : ConstantExpr {
    this() {
        super();
    }
    this(InstructionKind_ Opc, Constant C, IR类型_ Ty) {
        super();
        this.Opc = Opc;
        this.类型 = Ty;
        .追加!(Value)(this.Ops, C);
    }
}
class BinaryConstantExpr : ConstantExpr {
    this() {
        super();
    }
    this(InstructionKind_ Opc, Constant C1, Constant C2, ulong Flags) {
        super();
        this.Opc = Opc;
        this.类型 = C1.类型;
        .追加!(Value)(this.Ops, C1, C2);
        this.SubclassOptionalData = Flags;
    }
}
class SelectConstantExpr : ConstantExpr {
    this() {
        super();
    }
    this(Constant C1, Constant C2, Constant C3) {
        super();
        this.Opc = InstructionKind_.Select;
        this.类型 = C1.类型;
        .追加!(Value)(this.Ops, C1, C2, C3);
    }
}
class ExtractElementConstantExpr : ConstantExpr {
    this() {
        super();
    }
    this(Constant C1, Constant C2) {
        super();
        this.Opc = InstructionKind_.ExtractElement;
        this.类型 = (cast(向量类型_)(C1.类型)).元素类型;
        .追加!(Value)(this.Ops, C1, C2);
    }
}
class InsertElementConstantExpr : ConstantExpr {
    this() {
        super();
    }
    this(Constant C1, Constant C2, Constant C3) {
        super();
        this.Opc = InstructionKind_.InsertElement;
        this.类型 = C1.类型;
        .追加!(Value)(this.Ops, C1, C2, C3);
    }
}
class Metadata : Value {
    ulong MDK;
    StorageType_ Storage;
    this() {
        super();
        this.MDK = -1;
        this.Storage = StorageType_.Uniqued;
    }
}
class MetadataAsValue : Metadata {
    Metadata MD;
    this() {
        super();
        this.种类 = ValueTy_.MetadataAsValueVal;
        this.MDK = MetadataKind_.MetadataAsValueKind;
        this.MD = ··null!(Metadata);
    }
    this(Metadata MD) {
        this();
        this.MD = MD;
    }
}
class ValueAsMetadata : Metadata {
    Value V;
    this() {
        super();
        this.MDK = MetadataKind_.无效值_;
        this.V = ··null!(Value);
    }
    this(MetadataKind_ mdk, Value V) {
        this();
        this.MDK = mdk;
        this.V = V;
    }
}
class ConstantAsMetadata : ValueAsMetadata {
    this() { }
    this(Constant C) {
        super(MetadataKind_.ConstantAsMetadataKind, C);
    }
}
class LocalAsMetadata : ValueAsMetadata {
    this() { }
    this(Value Local) {
        super(MetadataKind_.LocalAsMetadataKind, Local);
    }
}
class MDString : Metadata {
    词典_!(MDString) Entry;
    this() {
        super();
        this.MDK = MetadataKind_.MDStringKind;
        this.Entry = ··null!(词典_!(MDString));
    }
}
class MDNode : Metadata {
    this() {
        super();
    }
    this(ulong ID, StorageType_ Storage, Metadata[] Ops1, Metadata[] Ops2 = ··null!(Metadata[])) {
        super();
        this.MDK = ID;
        this.Storage = Storage;
        this.Ops.length = Ops1.length + (Ops2 ? Ops2.length : 0);
        .追加!(Value)(this.Ops, cast(Value[])(Ops1));
        if (Ops2 !is ··null!(Metadata[])) {
            .追加!(Value)(this.Ops, cast(Value[])(Ops2));
        }
    }
}
class MDTuple : MDNode {
    ulong Hash;
    this() {
        super();
        this.Hash = 0;
    }
    this(StorageType_ Storage, ulong Hash, Metadata[] Vals) {
        super(MetadataKind_.MDTupleKind, Storage, Vals);
        this.Hash = Hash;
    }
}
class ParamInfo : Value {
    IR节点_ n;
    Value V;
    特性组_ Attrs;
    this() { }
    this(IR节点_ n, Value V = ··null!(Value), 特性组_ Attrs = ··null!(特性组_)) {
        super();
        this.n = n;
        this.V = V;
        this.Attrs = Attrs;
    }
}
class BundleDef : Value {
    dstring Tag;
    Value[] Inputs;
    this() { }
    this(dstring Tag, Value[] Inputs) {
        super();
        this.Tag = Tag;
        this.Inputs = Inputs;
    }
}
class BundleDefS : Value {
    this() { }
    this(BundleDef[] bs) {
        super();
        this.Ops = cast(Value[])(bs);
    }
}
class 特性组_ {
    ubyte[] 枚举特性;
    整数特性_[] 整数特性;
    词典_!(文本特性_) 文本特性;
    对齐特性_[] 对齐特性;
    类型特性_[] 类型特性;
    this() {
        this.枚举特性 = 创建数组!(ubyte)();
        this.枚举特性.length = 12;
        this.整数特性 = 创建数组!(整数特性_)();
        this.整数特性.length = 6;
        this.对齐特性 = 创建数组!(对齐特性_)();
        this.对齐特性.length = 2;
        this.类型特性 = 创建数组!(类型特性_)();
        this.类型特性.length = 6;
        this.文本特性 = new 词典_!(文本特性_)();
    }
}
class IR符号_ : 符号_ {
    long 合并Id;
    IR类型_ 类型;
    IR类型_ 声明类型;
    Value 声明值;
    符号标志_ isReferenced;
    词典_!(基础节点_) 引用者集合;
    this() { }
    this(long 标志, dstring 名称) {
        super(TK.Ir, 标志, 名称);
        this.合并Id = 0;
        this.类型 = ··null!(IR类型_);
        this.声明类型 = ··null!(IR类型_);
        this.isReferenced = ··null!(符号标志_);
        this.引用者集合 = ··null!(词典_!(基础节点_));
        this.声明值 = ··null!(Value);
    }
}
class 编译选项_ : 编译选项基类_ {
    this() { }
    this(dstring id) {
        super(id);
    }
}
